@webex/calling 3.12.0-next.6 → 3.12.0-next.61

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

@@ -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,12 +100,14 @@ 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, retry429Cb, restoreRegCb, serverCount = 1) {
+    let shouldDisconnect = false;
     const lineError = createLineError('', {}, ERROR_TYPE.DEFAULT, RegistrationStatus.INACTIVE);
     const errorCode = Number(err.statusCode);
     let finalError = false;
@@ -90,6 +118,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 +126,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 +134,7 @@ 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.TOO_MANY_REQUESTS: {
@@ -112,20 +143,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 +169,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 };
             }
             const code = Number(errorBody.errorCode);
             log.warn(`Error code found : ${code}`, loggerContext);
@@ -147,6 +182,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 +191,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 +199,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,6 +207,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;
@@ -177,9 +216,10 @@ export async function handleRegistrationErrors(err, emitterCb, loggerContext, re
             updateLineErrorContext(loggerContext, ERROR_TYPE.DEFAULT, 'Unknown error', RegistrationStatus.INACTIVE, lineError);
             log.warn(`Unknown Error`, loggerContext);
             emitterCb(lineError, finalError);
+            shouldDisconnect = serverCount > 1;
         }
     }
-    return finalError;
+    return { finalError, shouldDisconnect };
 }
 export async function handleCallingClientErrors(err, emitterCb, loggerContext) {
     const clientError = createClientError('', {}, ERROR_TYPE.DEFAULT, RegistrationStatus.INACTIVE);
@@ -623,10 +663,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,13 +679,16 @@ 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 {
@@ -851,7 +894,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 +909,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 +981,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 };