@webex/calling 3.11.0 → 3.12.0-llmrefactor.2

package/dist/module/Events/types.js

@@ -1,10 +1,15 @@
 import { LINE_EVENTS } from '../CallingClient/line/types';
+import { MOBIUS_SOCKET_DISCONNECT_REASON } from '../CallingClient/utils/constants';
+export { MOBIUS_SOCKET_DISCONNECT_REASON };
 export var COMMON_EVENT_KEYS;
 (function (COMMON_EVENT_KEYS) {
     COMMON_EVENT_KEYS["CB_VOICEMESSAGE_CONTENT_GET"] = "call_back_voicemail_content_get";
     COMMON_EVENT_KEYS["CALL_HISTORY_USER_SESSION_INFO"] = "callHistory:user_recent_sessions";
     COMMON_EVENT_KEYS["CALL_HISTORY_USER_VIEWED_SESSIONS"] = "callHistory:user_viewed_sessions";
     COMMON_EVENT_KEYS["CALL_HISTORY_USER_SESSIONS_DELETED"] = "callHistory:user_sessions_deleted";
+    COMMON_EVENT_KEYS["CALL_RECORDING_CREATED"] = "callRecording:created";
+    COMMON_EVENT_KEYS["CALL_RECORDING_UPDATED"] = "callRecording:updated";
+    COMMON_EVENT_KEYS["CALL_RECORDING_DELETED"] = "callRecording:deleted";
 })(COMMON_EVENT_KEYS || (COMMON_EVENT_KEYS = {}));
 export var LINE_EVENT_KEYS;
 (function (LINE_EVENT_KEYS) {
@@ -16,6 +21,8 @@ export var CALLING_CLIENT_EVENT_KEYS;
     CALLING_CLIENT_EVENT_KEYS["OUTGOING_CALL"] = "callingClient:outgoing_call";
     CALLING_CLIENT_EVENT_KEYS["USER_SESSION_INFO"] = "callingClient:user_recent_sessions";
     CALLING_CLIENT_EVENT_KEYS["ALL_CALLS_CLEARED"] = "callingClient:all_calls_cleared";
+    CALLING_CLIENT_EVENT_KEYS["MOBIUS_SOCKET_CONNECTED"] = "callingClient:mobius_socket_connected";
+    CALLING_CLIENT_EVENT_KEYS["MOBIUS_SOCKET_DISCONNECTED"] = "callingClient:mobius_socket_disconnected";
 })(CALLING_CLIENT_EVENT_KEYS || (CALLING_CLIENT_EVENT_KEYS = {}));
 export var CALL_EVENT_KEYS;
 (function (CALL_EVENT_KEYS) {
@@ -65,25 +72,31 @@ export var MOBIUS_EVENT_KEYS;
     MOBIUS_EVENT_KEYS["CALL_SESSION_EVENT_LEGACY"] = "event:janus.user_sessions";
     MOBIUS_EVENT_KEYS["CALL_SESSION_EVENT_VIEWED"] = "event:janus.user_viewed_sessions";
     MOBIUS_EVENT_KEYS["CALL_SESSION_EVENT_DELETED"] = "event:janus.user_sessions_deleted";
+    MOBIUS_EVENT_KEYS["RECORDING_EVENT_CREATED"] = "event:convergedRecordings.created";
+    MOBIUS_EVENT_KEYS["RECORDING_EVENT_UPDATED"] = "event:convergedRecordings.updated";
+    MOBIUS_EVENT_KEYS["RECORDING_EVENT_DELETED"] = "event:convergedRecordings.deleted";
 })(MOBIUS_EVENT_KEYS || (MOBIUS_EVENT_KEYS = {}));
 export var MEDIA_CONNECTION_EVENT_KEYS;
 (function (MEDIA_CONNECTION_EVENT_KEYS) {
     MEDIA_CONNECTION_EVENT_KEYS["ROAP_MESSAGE_TO_SEND"] = "roap:messageToSend";
     MEDIA_CONNECTION_EVENT_KEYS["MEDIA_TYPE_AUDIO"] = "audio";
 })(MEDIA_CONNECTION_EVENT_KEYS || (MEDIA_CONNECTION_EVENT_KEYS = {}));
+export var RECORDING_EVENT_TYPE;
+(function (RECORDING_EVENT_TYPE) {
+    RECORDING_EVENT_TYPE["CREATED"] = "convergedRecordings.created";
+    RECORDING_EVENT_TYPE["UPDATED"] = "convergedRecordings.updated";
+    RECORDING_EVENT_TYPE["DELETED"] = "convergedRecordings.deleted";
+})(RECORDING_EVENT_TYPE || (RECORDING_EVENT_TYPE = {}));
+export var RECORDING_EVENT_SUBTYPE;
+(function (RECORDING_EVENT_SUBTYPE) {
+    RECORDING_EVENT_SUBTYPE["TRASH"] = "TRASH";
+    RECORDING_EVENT_SUBTYPE["PURGE"] = "PURGE";
+    RECORDING_EVENT_SUBTYPE["RESTORE"] = "RESTORE";
+    RECORDING_EVENT_SUBTYPE["SUMMARY_CREATE"] = "SUMMARY_CREATE";
+})(RECORDING_EVENT_SUBTYPE || (RECORDING_EVENT_SUBTYPE = {}));
 var CALL_STATE;
 (function (CALL_STATE) {
     CALL_STATE["HELD"] = "held";
     CALL_STATE["REMOTE_HELD"] = "remoteheld";
     CALL_STATE["CONNECTED"] = "connected";
 })(CALL_STATE || (CALL_STATE = {}));
-export const WEBSOCKET_SCOPE = 'mobius';
-export var WEBSOCKET_KEYS;
-(function (WEBSOCKET_KEYS) {
-    WEBSOCKET_KEYS["CALL_PROGRESS"] = "callprogress";
-    WEBSOCKET_KEYS["CALL_CONNECTED"] = "callconnected";
-    WEBSOCKET_KEYS["CALL_DISCONNECTED"] = "callconnected";
-    WEBSOCKET_KEYS["CALL_INFO"] = "callinfo";
-    WEBSOCKET_KEYS["CALL"] = "call";
-    WEBSOCKET_KEYS["ROAP"] = "ROAP";
-})(WEBSOCKET_KEYS || (WEBSOCKET_KEYS = {}));

package/dist/module/Metrics/index.js

@@ -260,7 +260,7 @@ class MetricManager {
             this.webex.internal.metrics.submitClientMetrics(name, data);
         }
     }
-    submitMediaMetric(name, metricAction, type, callId, correlationId, localSdp, remoteSdp, callError) {
+    submitMediaMetric(name, metricAction, type, callId, correlationId, localSdp, remoteSdp, state, callError) {
         let data;
         switch (name) {
             case METRIC_EVENT.MEDIA: {
@@ -278,6 +278,7 @@ class MetricManager {
                         correlation_id: correlationId,
                         local_media_details: localSdp,
                         remote_media_details: remoteSdp,
+                        state,
                     },
                     type,
                 };
@@ -396,6 +397,52 @@ class MetricManager {
             this.webex.internal.metrics.submitClientMetrics(name, data);
         }
     }
+    submitMobiusSocketMetric(name, metricAction, type, wssUrl, trackingId, error, eventType) {
+        let data;
+        const commonTags = {
+            action: metricAction,
+            device_id: this.deviceInfo?.device?.deviceId,
+            service_indicator: this.serviceIndicator,
+        };
+        const commonFields = {
+            device_url: this.deviceInfo?.device?.clientDeviceUri,
+            mobius_url: this.deviceInfo?.device?.uri,
+            calling_sdk_version: process.env.CALLING_SDK_VERSION || VERSION,
+            wss_url: wssUrl,
+            tracking_id: trackingId,
+            event_type: eventType,
+        };
+        switch (name) {
+            case METRIC_EVENT.MOBIUS_SOCKET: {
+                data = {
+                    tags: commonTags,
+                    fields: commonFields,
+                    type,
+                };
+                break;
+            }
+            case METRIC_EVENT.MOBIUS_SOCKET_ERROR: {
+                data = {
+                    tags: commonTags,
+                    fields: {
+                        ...commonFields,
+                        error,
+                    },
+                    type,
+                };
+                break;
+            }
+            default:
+                log.warn('Invalid metric name received. Rejecting request to submit metric.', {
+                    file: METRIC_FILE,
+                    method: 'submitMobiusSocketMetric',
+                });
+                break;
+        }
+        if (data) {
+            this.webex.internal.metrics.submitClientMetrics(name, data);
+        }
+    }
 }
 export const getMetricManager = (webex, indicator) => {
     if (!metricManager && webex) {

package/dist/module/Metrics/types.js

@@ -20,6 +20,8 @@ export var METRIC_EVENT;
     METRIC_EVENT["UPLOAD_LOGS_SUCCESS"] = "web-calling-sdk-upload-logs-success";
     METRIC_EVENT["UPLOAD_LOGS_FAILED"] = "web-calling-sdk-upload-logs-failed";
     METRIC_EVENT["MOBIUS_DISCOVERY"] = "web-calling-sdk-mobius-discovery";
+    METRIC_EVENT["MOBIUS_SOCKET"] = "web-calling-sdk-mobius-socket";
+    METRIC_EVENT["MOBIUS_SOCKET_ERROR"] = "web-calling-sdk-mobius-socket-error";
 })(METRIC_EVENT || (METRIC_EVENT = {}));
 export var MOBIUS_SERVER_ACTION;
 (function (MOBIUS_SERVER_ACTION) {
@@ -32,6 +34,14 @@ export var REG_ACTION;
     REG_ACTION["DEREGISTER"] = "deregister";
     REG_ACTION["KEEPALIVE_FAILURE"] = "keepaliveFailure";
 })(REG_ACTION || (REG_ACTION = {}));
+export var MOBIUS_SOCKET_ACTION;
+(function (MOBIUS_SOCKET_ACTION) {
+    MOBIUS_SOCKET_ACTION["CONNECT"] = "connect";
+    MOBIUS_SOCKET_ACTION["DISCONNECT"] = "disconnect";
+    MOBIUS_SOCKET_ACTION["LISTENER_REGISTERED"] = "listener_registered";
+    MOBIUS_SOCKET_ACTION["LISTENER_UNREGISTERED"] = "listener_unregistered";
+    MOBIUS_SOCKET_ACTION["REGISTRATION_DOWN"] = "registration_down";
+})(MOBIUS_SOCKET_ACTION || (MOBIUS_SOCKET_ACTION = {}));
 export var TRANSFER_ACTION;
 (function (TRANSFER_ACTION) {
     TRANSFER_ACTION["BLIND"] = "TRANSFER_BLIND";
@@ -54,3 +64,11 @@ export var CONNECTION_ACTION;
     CONNECTION_ACTION["MERCURY_DOWN"] = "mercury_down";
     CONNECTION_ACTION["MERCURY_UP"] = "mercury_up";
 })(CONNECTION_ACTION || (CONNECTION_ACTION = {}));
+export var MEDIA_CONNECTION_ACTION;
+(function (MEDIA_CONNECTION_ACTION) {
+    MEDIA_CONNECTION_ACTION["ICE_GATHERING_STATE_CHANGED"] = "ICE_GATHERING_STATE_CHANGED";
+    MEDIA_CONNECTION_ACTION["PEER_CONNECTION_STATE_CHANGED"] = "PEER_CONNECTION_STATE_CHANGED";
+    MEDIA_CONNECTION_ACTION["ICE_CONNECTION_STATE_CHANGED"] = "ICE_CONNECTION_STATE_CHANGED";
+    MEDIA_CONNECTION_ACTION["ICE_CANDIDATE_ERROR"] = "ICE_CANDIDATE_ERROR";
+    MEDIA_CONNECTION_ACTION["ROAP_FAILURE"] = "ROAP_FAILURE";
+})(MEDIA_CONNECTION_ACTION || (MEDIA_CONNECTION_ACTION = {}));

package/dist/module/api.js

@@ -3,5 +3,6 @@ import { CallSettings, createCallSettingsClient } from './CallSettings/CallSetti
 import { CallingClient, createClient } from './CallingClient/CallingClient';
 import { ContactsClient, createContactsClient } from './Contacts/ContactsClient';
 import { Voicemail, createVoicemailClient } from './Voicemail/Voicemail';
-export { CallHistory, CallSettings, CallingClient, ContactsClient, Voicemail };
-export { createCallHistoryClient, createCallSettingsClient, createClient, createContactsClient, createVoicemailClient, };
+import { CallRecording, createCallRecordingClient } from './CallRecording/CallRecording';
+export { CallHistory, CallSettings, CallingClient, ContactsClient, Voicemail, CallRecording };
+export { createCallHistoryClient, createCallSettingsClient, createClient, createContactsClient, createVoicemailClient, createCallRecordingClient, };

package/dist/module/common/Utils.js

@@ -7,7 +7,7 @@ import { DEVICE_ERROR_CODE, ERROR_CODE, ERROR_TYPE, CALL_ERROR_CODE, } from '../
 import { CALLING_BACKEND, HTTP_METHODS, RegistrationStatus, SORT, ServiceIndicator, } from './types';
 import log from '../Logger';
 import { createClientError } from '../Errors/catalog/CallingDeviceError';
-import { BYTES_RECEIVED, BYTES_SENT, CALLING_USER_AGENT, CISCO_DEVICE_URL, CODEC_ID, DUMMY_METRICS, INBOUND_CODEC_MATCH, INBOUND_RTP, JITTER_BUFFER_DELAY, JITTER_BUFFER_EMITTED_COUNT, LOCAL_CANDIDATE_ID, MEDIA_ID, MEDIA_SOURCE, MIME_TYPE, NETWORK_TYPE, OUTBOUND_CODEC_MATCH, OUTBOUND_RTP, PACKETS_DISCARDED, PACKETS_LOST, PACKETS_RECEIVED, PACKETS_SENT, REMOTE_INBOUND_RTP, ROUND_TRIP_TIME_MEASUREMENTS, RTC_CODEC, RTC_ICE_CANDIDATE, RTC_ICE_CANDIDATE_PAIR, RTP_RX_STAT, RTP_TX_STAT, SELECTED_CANDIDATE_PAIR_ID, SPARK_USER_AGENT, TARGET_BIT_RATE, TIMESTAMP, TOTAL_ROUND_TRIP_TIME, TOTAL_SAMPLES_DURATION, TRANSPORT, TYPE, URL_ENDPOINT, UTILS_FILE, METHODS, DEFAULT_KEEPALIVE_INTERVAL, } from '../CallingClient/constants';
+import { BYTES_RECEIVED, BYTES_SENT, CALLING_USER_AGENT, CISCO_DEVICE_URL, CODEC_ID, DUMMY_METRICS, INBOUND_CODEC_MATCH, INBOUND_RTP, JITTER_BUFFER_DELAY, JITTER_BUFFER_EMITTED_COUNT, LOCAL_CANDIDATE_ID, MEDIA_ID, MEDIA_SOURCE, MIME_TYPE, NETWORK_TYPE, OUTBOUND_CODEC_MATCH, OUTBOUND_RTP, PACKETS_DISCARDED, PACKETS_LOST, PACKETS_RECEIVED, PACKETS_SENT, REMOTE_INBOUND_RTP, ROUND_TRIP_TIME_MEASUREMENTS, RTC_CODEC, RTC_ICE_CANDIDATE, RTC_ICE_CANDIDATE_PAIR, RTP_RX_STAT, RTP_TX_STAT, SELECTED_CANDIDATE_PAIR_ID, SPARK_USER_AGENT, TARGET_BIT_RATE, TIMESTAMP, TOTAL_ROUND_TRIP_TIME, TOTAL_SAMPLES_DURATION, TRANSPORT, TYPE, URL_ENDPOINT, UTILS_FILE, METHODS, DEFAULT_KEEPALIVE_INTERVAL, SESSION_SUPERSEDED_MESSAGE, } from '../CallingClient/constants';
 import { DEVICES, ITEMS, SETTINGS, VALUES, KEY, TIME, PLACEHOLDER_KEY, XSI_ACTION_ENDPOINT_ORG_URL_PARAM, XSI_ACTION_ENDPOINT, INFER_ID_CONSTANT, BW_XSI_URL, ENTITLEMENT_BASIC, ENTITLEMENT_BROADWORKS_CONN, ENTITLEMENT_STANDARD, NATIVE_WEBEX_TEAMS_CALLING, NATIVE_SIP_CALL_TO_UCM, BW_XSI_ENDPOINT_VERSION, IDENTITY_ENDPOINT_RESOURCE, SCIM_ENDPOINT_RESOURCE, SCIM_USER_FILTER, WEBEX_API_PROD, WEBEX_API_BTS, BW_XSI_ENDPOINT_VERSION_WITH_SLASH, } from './constants';
 import SDKConnector from '../SDKConnector';
 import { createLineError } from '../Errors/catalog/LineError';
@@ -18,18 +18,32 @@ export function filterMobiusUris(mobiusServers, defaultMobiusUrl) {
     };
     const urisArrayPrimary = [];
     const urisArrayBackup = [];
+    const wssArrayPrimary = [];
+    const wssArrayBackup = [];
     if (mobiusServers?.primary?.uris) {
         log.info('Adding Primary uris', logContext);
         for (const uri of mobiusServers.primary.uris) {
             urisArrayPrimary.push(`${uri}${URL_ENDPOINT}`);
         }
     }
+    if (mobiusServers?.primary?.wss) {
+        log.info('Adding Primary wss uris', logContext);
+        for (const wssUri of mobiusServers.primary.wss) {
+            wssArrayPrimary.push(wssUri);
+        }
+    }
     if (mobiusServers?.backup?.uris) {
         log.info('Adding Backup uris', logContext);
         for (const uri of mobiusServers.backup.uris) {
             urisArrayBackup.push(`${uri}${URL_ENDPOINT}`);
         }
     }
+    if (mobiusServers?.backup?.wss) {
+        log.info('Adding Backup wss uris', logContext);
+        for (const wssUri of mobiusServers.backup.wss) {
+            wssArrayBackup.push(wssUri);
+        }
+    }
     log.info('Adding Default uri', logContext);
     if (!urisArrayPrimary.length && !urisArrayBackup.length) {
         urisArrayPrimary.push(`${defaultMobiusUrl}${URL_ENDPOINT}`);
@@ -39,6 +53,8 @@ export function filterMobiusUris(mobiusServers, defaultMobiusUrl) {
     }
     const primaryUris = [];
     const backupUris = [];
+    const primaryWss = [];
+    const backupWss = [];
     for (let i = 0; i < urisArrayPrimary.length; i += 1) {
         if (primaryUris.indexOf(urisArrayPrimary[i]) === -1) {
             primaryUris.push(urisArrayPrimary[i]);
@@ -49,7 +65,17 @@ export function filterMobiusUris(mobiusServers, defaultMobiusUrl) {
             backupUris.push(urisArrayBackup[i]);
         }
     }
-    return { primary: primaryUris, backup: backupUris };
+    for (let i = 0; i < wssArrayPrimary.length; i += 1) {
+        if (primaryWss.indexOf(wssArrayPrimary[i]) === -1) {
+            primaryWss.push(wssArrayPrimary[i]);
+        }
+    }
+    for (let i = 0; i < wssArrayBackup.length; i += 1) {
+        if (backupWss.indexOf(wssArrayBackup[i]) === -1) {
+            backupWss.push(wssArrayBackup[i]);
+        }
+    }
+    return { primary: primaryUris, backup: backupUris, primaryWss, backupWss };
 }
 function updateCallErrorContext(errContext, type, message, correlationId, callError) {
     const errObj = {};
@@ -74,15 +100,25 @@ function updateErrorContext(errContext, type, message, clientError) {
     errObj.message = message;
     clientError.setError(errObj);
 }
-export function emitFinalFailure(emitterCb, loggerContext) {
-    const clientError = createLineError('', {}, ERROR_TYPE.DEFAULT, RegistrationStatus.INACTIVE);
-    updateLineErrorContext(loggerContext, ERROR_TYPE.SERVICE_UNAVAILABLE, 'An unknown error occurred. Wait a moment and try again. Please contact the administrator if the problem persists.', RegistrationStatus.INACTIVE, clientError);
+export function emitFinalFailure(emitterCb, loggerContext, message) {
+    const clientError = createLineError(message || '', {}, ERROR_TYPE.DEFAULT, RegistrationStatus.INACTIVE);
+    updateLineErrorContext(loggerContext, ERROR_TYPE.SERVICE_UNAVAILABLE, message ||
+        'An unknown error occurred. Wait a moment and try again. Please contact the administrator if the problem persists.', RegistrationStatus.INACTIVE, clientError);
     emitterCb(clientError);
 }
-export async function handleRegistrationErrors(err, emitterCb, loggerContext, retry429Cb, restoreRegCb) {
+export async function handleRegistrationErrors(err, emitterCb, loggerContext, handlers = {}, serverCount = 1) {
+    const { retry429Cb, restoreRegCb, sessionSupersededCb } = handlers;
+    let shouldDisconnect = false;
+    let handledByCallback = false;
     const lineError = createLineError('', {}, ERROR_TYPE.DEFAULT, RegistrationStatus.INACTIVE);
     const errorCode = Number(err.statusCode);
     let finalError = false;
+    const handleUnknownError = () => {
+        updateLineErrorContext(loggerContext, ERROR_TYPE.DEFAULT, 'Unknown error', RegistrationStatus.INACTIVE, lineError);
+        log.warn(`Unknown Error`, loggerContext);
+        emitterCb(lineError, finalError);
+        shouldDisconnect = serverCount > 1;
+    };
     log.warn(`Status code: -> ${errorCode}`, loggerContext);
     switch (errorCode) {
         case ERROR_CODE.BAD_REQUEST: {
@@ -90,6 +126,7 @@ export async function handleRegistrationErrors(err, emitterCb, loggerContext, re
             log.warn(`400 Bad Request`, loggerContext);
             updateLineErrorContext(loggerContext, ERROR_TYPE.BAD_REQUEST, 'Invalid input. Please verify the required parameters, sign out and then sign back in with the valid data', RegistrationStatus.INACTIVE, lineError);
             emitterCb(lineError, finalError);
+            shouldDisconnect = serverCount > 1;
             break;
         }
         case ERROR_CODE.UNAUTHORIZED: {
@@ -97,6 +134,7 @@ export async function handleRegistrationErrors(err, emitterCb, loggerContext, re
             log.warn(`401 Unauthorized`, loggerContext);
             updateLineErrorContext(loggerContext, ERROR_TYPE.TOKEN_ERROR, 'User is unauthorized due to an expired token. Sign out, then sign back in.', RegistrationStatus.INACTIVE, lineError);
             emitterCb(lineError, finalError);
+            shouldDisconnect = serverCount > 1;
             break;
         }
         case ERROR_CODE.DEVICE_NOT_FOUND: {
@@ -104,6 +142,20 @@ export async function handleRegistrationErrors(err, emitterCb, loggerContext, re
             log.warn(`404 Device Not Found`, loggerContext);
             updateLineErrorContext(loggerContext, ERROR_TYPE.NOT_FOUND, 'Webex Calling is unable to find your device. Sign out, then sign back in', RegistrationStatus.INACTIVE, lineError);
             emitterCb(lineError, finalError);
+            shouldDisconnect = serverCount > 1;
+            break;
+        }
+        case ERROR_CODE.CONFLICT: {
+            if (!sessionSupersededCb) {
+                handleUnknownError();
+                break;
+            }
+            finalError = true;
+            handledByCallback = true;
+            log.warn(`409 Conflict: session superseded by another device for this user`, loggerContext);
+            updateLineErrorContext(loggerContext, ERROR_TYPE.SESSION_SUPERSEDED, SESSION_SUPERSEDED_MESSAGE, RegistrationStatus.INACTIVE, lineError);
+            await sessionSupersededCb(lineError);
+            shouldDisconnect = false;
             break;
         }
         case ERROR_CODE.TOO_MANY_REQUESTS: {
@@ -112,20 +164,23 @@ export async function handleRegistrationErrors(err, emitterCb, loggerContext, re
             const caller = loggerContext.method || 'handleErrors';
             if (retry429Cb && err.headers) {
                 const retryAfter = Number(err.headers['retry-after']);
-                retry429Cb(retryAfter, caller);
+                await retry429Cb(retryAfter, caller);
             }
+            shouldDisconnect = false;
             break;
         }
         case ERROR_CODE.INTERNAL_SERVER_ERROR: {
             log.warn(`500 Internal Server Error`, loggerContext);
             updateLineErrorContext(loggerContext, ERROR_TYPE.SERVER_ERROR, 'An unknown error occurred while placing the request. Wait a moment and try again.', RegistrationStatus.INACTIVE, lineError);
             emitterCb(lineError, finalError);
+            shouldDisconnect = serverCount > 1;
             break;
         }
         case ERROR_CODE.SERVICE_UNAVAILABLE: {
             log.warn(`503 Service Unavailable`, loggerContext);
             updateLineErrorContext(loggerContext, ERROR_TYPE.SERVICE_UNAVAILABLE, 'An error occurred on the server while processing the request. Wait a moment and try again.', RegistrationStatus.INACTIVE, lineError);
             emitterCb(lineError, finalError);
+            shouldDisconnect = serverCount > 1;
             break;
         }
         case ERROR_CODE.FORBIDDEN: {
@@ -135,7 +190,8 @@ export async function handleRegistrationErrors(err, emitterCb, loggerContext, re
                 log.warn('Error response has no body, throwing default error', loggerContext);
                 updateLineErrorContext(loggerContext, ERROR_TYPE.FORBIDDEN_ERROR, 'An unauthorized action has been received. This action has been blocked. Please contact the administrator if this persists.', RegistrationStatus.INACTIVE, lineError);
                 emitterCb(lineError, finalError);
-                return finalError;
+                shouldDisconnect = serverCount > 1;
+                return { finalError, shouldDisconnect, handledByCallback };
             }
             const code = Number(errorBody.errorCode);
             log.warn(`Error code found : ${code}`, loggerContext);
@@ -147,6 +203,7 @@ export async function handleRegistrationErrors(err, emitterCb, loggerContext, re
                         const caller = loggerContext.method || 'handleErrors';
                         await restoreRegCb(errorBody, caller);
                     }
+                    shouldDisconnect = false;
                     break;
                 }
                 case DEVICE_ERROR_CODE.DEVICE_CREATION_DISABLED: {
@@ -155,6 +212,7 @@ export async function handleRegistrationErrors(err, emitterCb, loggerContext, re
                     updateLineErrorContext(loggerContext, ERROR_TYPE.FORBIDDEN_ERROR, errorMessage, RegistrationStatus.INACTIVE, lineError);
                     log.warn(errorMessage, loggerContext);
                     emitterCb(lineError, true);
+                    shouldDisconnect = true;
                     break;
                 }
                 case DEVICE_ERROR_CODE.DEVICE_CREATION_FAILED: {
@@ -162,6 +220,7 @@ export async function handleRegistrationErrors(err, emitterCb, loggerContext, re
                     updateLineErrorContext(loggerContext, ERROR_TYPE.FORBIDDEN_ERROR, errorMessage, RegistrationStatus.INACTIVE, lineError);
                     log.warn(errorMessage, loggerContext);
                     emitterCb(lineError, finalError);
+                    shouldDisconnect = serverCount > 1;
                     break;
                 }
                 default: {
@@ -169,17 +228,16 @@ export async function handleRegistrationErrors(err, emitterCb, loggerContext, re
                     updateLineErrorContext(loggerContext, ERROR_TYPE.FORBIDDEN_ERROR, errorMessage, RegistrationStatus.INACTIVE, lineError);
                     log.warn(errorMessage, loggerContext);
                     emitterCb(lineError, finalError);
+                    shouldDisconnect = serverCount > 1;
                 }
             }
             break;
         }
         default: {
-            updateLineErrorContext(loggerContext, ERROR_TYPE.DEFAULT, 'Unknown error', RegistrationStatus.INACTIVE, lineError);
-            log.warn(`Unknown Error`, loggerContext);
-            emitterCb(lineError, finalError);
+            handleUnknownError();
         }
     }
-    return finalError;
+    return { finalError, shouldDisconnect, handledByCallback };
 }
 export async function handleCallingClientErrors(err, emitterCb, loggerContext) {
     const clientError = createClientError('', {}, ERROR_TYPE.DEFAULT, RegistrationStatus.INACTIVE);
@@ -623,10 +681,10 @@ export function parseMediaQualityStatistics(stats) {
 export const waitForMsecs = (msec) => new Promise((resolve) => {
     setTimeout(resolve, msec);
 });
-export function getCallingBackEnd(webex) {
-    const entModels = webex.internal.device.features.entitlement.models;
+export function resolveCallingBackend(device) {
+    const entModels = device.features.entitlement.models;
     let callingBackend;
-    if (webex.internal.device.callingBehavior === NATIVE_WEBEX_TEAMS_CALLING) {
+    if (device.callingBehavior === NATIVE_WEBEX_TEAMS_CALLING) {
         for (let i = 0; i < entModels.length; i += 1) {
             if (entModels[i][VALUES][KEY] === ENTITLEMENT_BASIC ||
                 entModels[i][VALUES][KEY] === ENTITLEMENT_STANDARD) {
@@ -639,20 +697,25 @@ export function getCallingBackEnd(webex) {
             }
         }
     }
-    else if (webex.internal.device.callingBehavior === NATIVE_SIP_CALL_TO_UCM) {
+    else if (device.callingBehavior === NATIVE_SIP_CALL_TO_UCM) {
         callingBackend = CALLING_BACKEND.UCM;
     }
     else {
         callingBackend = CALLING_BACKEND.INVALID;
     }
-    return callingBackend;
+    return callingBackend || CALLING_BACKEND.INVALID;
+}
+export function getCallingBackEnd(webex) {
+    return resolveCallingBackend(webex.internal.device);
 }
 export async function getXsiActionEndpoint(webex, loggerContext, callingBackend) {
     try {
         switch (callingBackend) {
             case CALLING_BACKEND.WXC: {
+                const hydraEndpoint = webex.internal.services._serviceUrls?.hydra ||
+                    webex.internal.services.get(webex.internal.services._activeServices.hydra);
                 const userIdResponse = await webex.request({
-                    uri: `${webex.internal.services._serviceUrls.hydra}/${XSI_ACTION_ENDPOINT_ORG_URL_PARAM}`,
+                    uri: `${hydraEndpoint}/${XSI_ACTION_ENDPOINT_ORG_URL_PARAM}`,
                     method: HTTP_METHODS.GET,
                 });
                 log.log(`Response code: ${userIdResponse.statusCode}, Response trackingid: ${userIdResponse?.headers?.trackingid}`, {
@@ -851,7 +914,7 @@ export function inferIdFromUuid(id, decodeType) {
 function isValidServiceIndicator(indicator) {
     return Object.values(ServiceIndicator).some((v) => v === indicator);
 }
-function isValidServiceDomain(serviceData) {
+export function isValidServiceDomain(serviceData) {
     const regexp = /^[a-z0-9]+([-.]{1}[a-z0-9]+)*\.[a-z]{2,6}$/i;
     const { domain } = serviceData;
     if (!domain) {
@@ -866,9 +929,6 @@ export function validateServiceData(serviceData) {
     if (!isValidServiceIndicator(serviceData.indicator)) {
         throw new Error(`Invalid service indicator, Allowed values are: ${formattedValues}`);
     }
-    if (!isValidServiceDomain(serviceData)) {
-        throw new Error('Invalid service domain.');
-    }
 }
 export function modifySdpForIPv4(sdp) {
     try {
@@ -941,3 +1001,6 @@ export async function uploadLogs(metaData = {}, throwError = false) {
         return undefined;
     }
 }
+export function normalizeMobiusUris(urls) {
+    return urls.map((url) => (!url.endsWith('/') ? `${url}/` : url));
+}

package/dist/module/common/testUtil.js

@@ -1,4 +1,5 @@
 import platform from 'platform';
+import { CISCO_DEVICE_URL } from '../CallingClient/constants';
 const MediaSDKMock = jest.createMockFromModule('@webex/internal-media-core');
 export function getTestUtilsWebex() {
     return {
@@ -34,6 +35,9 @@ export function getTestUtilsWebex() {
                     entitlement: {
                         models: [{ _values: { key: 'bc-sp-standard' } }],
                     },
+                    developer: {
+                        get: jest.fn().mockReturnValue({ value: false }),
+                    },
                 },
             },
             encryption: {
@@ -61,6 +65,7 @@ export function getTestUtilsWebex() {
                     mercuryApi: 'https://mercury-api-intb.ciscospark.com/v1',
                     'ucmgmt-gateway': 'https://gw.telemetry.int-ucmgmt.cisco.com',
                     contactsService: 'https://contacts-service-a.wbx2.com/contact/api/v1',
+                    hydraDeveloperApi: 'https://integration.webexapis.com/v1',
                 },
                 fetchClientRegionInfo: jest.fn(),
                 getMobiusClusters: jest.fn(),
@@ -106,7 +111,7 @@ export const mockCallingClient = {
 export const getMockRequestTemplate = () => {
     return {
         headers: {
-            'cisco-device-url': 'https://wdm-intb.ciscospark.com/wdm/api/v1/devices/c5ae3b86-1bb7-40f1-a6a9-c296ee7e61d5',
+            [CISCO_DEVICE_URL]: 'https://wdm-intb.ciscospark.com/wdm/api/v1/devices/c5ae3b86-1bb7-40f1-a6a9-c296ee7e61d5',
             'spark-user-agent': 'webex-calling/beta',
         },
         service: 'mobius',

package/dist/module/common/types.js

@@ -3,6 +3,7 @@ export var ALLOWED_SERVICES;
 (function (ALLOWED_SERVICES) {
     ALLOWED_SERVICES["MOBIUS"] = "mobius";
     ALLOWED_SERVICES["JANUS"] = "janus";
+    ALLOWED_SERVICES["HYDRA_DEVELOPER_API"] = "hydraDeveloperApi";
 })(ALLOWED_SERVICES || (ALLOWED_SERVICES = {}));
 export var HTTP_METHODS;
 (function (HTTP_METHODS) {
@@ -62,6 +63,8 @@ export var WorkerMessageType;
 (function (WorkerMessageType) {
     WorkerMessageType["START_KEEPALIVE"] = "START_KEEPALIVE";
     WorkerMessageType["CLEAR_KEEPALIVE"] = "CLEAR_KEEPALIVE";
+    WorkerMessageType["SEND_KEEPALIVE"] = "SEND_KEEPALIVE";
+    WorkerMessageType["KEEPALIVE_RESULT"] = "KEEPALIVE_RESULT";
     WorkerMessageType["KEEPALIVE_SUCCESS"] = "KEEPALIVE_SUCCESS";
     WorkerMessageType["KEEPALIVE_FAILURE"] = "KEEPALIVE_FAILURE";
 })(WorkerMessageType || (WorkerMessageType = {}));

package/dist/module/index.js

@@ -4,13 +4,17 @@ import { createContactsClient } from './Contacts/ContactsClient';
 import { createClient } from './CallingClient/CallingClient';
 import { createCallHistoryClient } from './CallHistory/CallHistory';
 import { createVoicemailClient } from './Voicemail/Voicemail';
+import { createCallRecordingClient } from './CallRecording/CallRecording';
 import Logger from './Logger';
-export { createClient, createCallHistoryClient, createCallSettingsClient, createContactsClient, createMicrophoneStream, createVoicemailClient, Logger, NoiseReductionEffect, };
+export { createClient, createCallHistoryClient, createCallSettingsClient, createContactsClient, createMicrophoneStream, createVoicemailClient, createCallRecordingClient, Logger, NoiseReductionEffect, };
 export { ERROR_LAYER, ERROR_TYPE } from './Errors/types';
+export { RecordingStatus, RecordingRequestType, } from './CallRecording/types';
+export { getRemoteParty } from './CallRecording/utils';
 export { GroupType } from './Contacts/types';
 export { LINE_EVENTS } from './CallingClient/line/types';
-export { CALLING_CLIENT_EVENT_KEYS, CALL_EVENT_KEYS, Disposition, LINE_EVENT_KEYS, COMMON_EVENT_KEYS, } from './Events/types';
-export { CallDirection, CallType, SORT, SORT_BY, } from './common/types';
+export { CALLING_CLIENT_EVENT_KEYS, CALL_EVENT_KEYS, Disposition, LINE_EVENT_KEYS, COMMON_EVENT_KEYS, MOBIUS_SOCKET_DISCONNECT_REASON, } from './Events/types';
+export { CallDirection, CallType, CALLING_BACKEND, SORT, SORT_BY, } from './common/types';
+export { resolveCallingBackend } from './common/Utils';
 export { CallError, LineError } from './Errors';
 export { TransferType } from './CallingClient/calling/types';
 export { LOGGER } from './Logger/types';

package/dist/module/mobius-socket/config.js

@@ -0,0 +1,15 @@
+/*!
+ * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
+ */
+const mobiusSocketConfig = {
+    wssResponseTimeout: 10000,
+    backoffTimeMax: 32000,
+    backoffTimeReset: 1000,
+    initialConnectionMaxRetries: 0,
+    maxRetries: 3,
+    forceCloseDelay: 2000,
+    dedupCacheMaxSize: 1000,
+};
+export default {
+    mobiusSocket: mobiusSocketConfig,
+};

package/dist/module/mobius-socket/errors.js

@@ -0,0 +1,58 @@
+/*!
+ * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
+ */
+import { Exception } from '@webex/common';
+export class ConnectionError extends Exception {
+    static defaultMessage = 'Failed to connect to socket';
+    code;
+    reason;
+    constructor(event = {}) {
+        super(event);
+        this.code = event.code;
+        this.reason = event.reason;
+    }
+    parse(event = {}) {
+        return event.reason;
+    }
+}
+export class UnknownResponse extends ConnectionError {
+    static defaultMessage = 'UnknownResponse is produced by IE when we receive a 4XXX. You probably want to treat this like a NotFound';
+    constructor(event) {
+        super(event);
+    }
+}
+export class BadRequest extends ConnectionError {
+    static defaultMessage = 'BadRequest usually implies an attempt to use service account credentials';
+    constructor(event) {
+        super(event);
+    }
+}
+export class NotAuthorized extends ConnectionError {
+    static defaultMessage = 'Please refresh your access token';
+    constructor(event) {
+        super(event);
+    }
+}
+export class Forbidden extends ConnectionError {
+    static defaultMessage = 'Forbidden usually implies these credentials are not entitled for Webex';
+    constructor(event) {
+        super(event);
+    }
+}
+export function createWssResponseError(response, statusCode, statusMessage) {
+    const error = new Error(statusMessage || `Mobius websocket request failed with status ${statusCode || 'unknown'}`);
+    error.name = 'MobiusSocketResponseError';
+    error.statusCode = statusCode;
+    error.statusMessage = statusMessage;
+    error.response = response;
+    error.trackingId = response?.trackingId;
+    return error;
+}
+export function createTimeoutError(request) {
+    const errorPayload = {
+        type: 'response_event',
+        subtype: request.type,
+        trackingId: request.trackingId,
+    };
+    return createWssResponseError(errorPayload, 408, 'Mobius websocket response timed out');
+}

package/dist/module/mobius-socket/index.js

@@ -0,0 +1,24 @@
+/*!
+ * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
+ */
+import '@webex/internal-plugin-device';
+import '@webex/internal-plugin-feature';
+import '@webex/internal-plugin-metrics';
+import MobiusSocket from './mobius-socket';
+import config from './config';
+let mobiusSocketInstance;
+export function getMobiusSocketInstance(webex, mobiusSocketConfig) {
+    if (mobiusSocketInstance) {
+        return mobiusSocketInstance;
+    }
+    mobiusSocketInstance = new MobiusSocket(webex, {
+        ...config.mobiusSocket,
+        ...mobiusSocketConfig,
+    });
+    return mobiusSocketInstance;
+}
+export function resetMobiusSocketInstance() {
+    mobiusSocketInstance = undefined;
+}
+export default MobiusSocket;
+export { MobiusSocket };