@webex/calling 3.11.0 → 3.12.0-llmrefactor.2

package/dist/module/CallRecording/callRecordingFixtures.js

@@ -0,0 +1,201 @@
+import { MOBIUS_EVENT_KEYS, RECORDING_EVENT_SUBTYPE, RECORDING_EVENT_TYPE, } from '../Events/types';
+import { RecordingStatus } from './types';
+export const CALL_SESSION_ID = 'a1b2c3d4-1111-2222-3333-444455556666';
+export const RECORDING_ONE = {
+    id: '11111111-aaaa-bbbb-cccc-222222222222',
+    topic: 'Call with Alice',
+    createTime: '2024-05-01T10:01:05.000Z',
+    timeRecorded: '2024-05-01T10:00:00.000Z',
+    format: 'MP3',
+    serviceType: 'calling',
+    durationSeconds: 65,
+    sizeBytes: 1048576,
+    status: RecordingStatus.AVAILABLE,
+    ownerId: '8a67806f-fc4d-446b-a131-31e71ea5b0e9',
+    ownerEmail: 'owner@cisco.com',
+    ownerType: 'user',
+    storageRegion: 'US',
+    serviceData: {
+        locationId: 'loc-1',
+        callSessionId: CALL_SESSION_ID,
+    },
+};
+export const RECORDING_TWO = {
+    id: '33333333-dddd-eeee-ffff-444444444444',
+    topic: 'Call with Bob',
+    createTime: '2024-05-02T11:02:05.000Z',
+    timeRecorded: '2024-05-02T11:00:00.000Z',
+    format: 'MP3',
+    serviceType: 'calling',
+    durationSeconds: 120,
+    sizeBytes: 2097152,
+    status: RecordingStatus.AVAILABLE,
+    ownerId: '8a67806f-fc4d-446b-a131-31e71ea5b0e9',
+    ownerEmail: 'owner@cisco.com',
+    ownerType: 'user',
+    storageRegion: 'US',
+    serviceData: {
+        locationId: 'loc-1',
+        callSessionId: 'ffffffff-9999-8888-7777-666666666666',
+    },
+};
+export const MOCK_RECORDING_LIST_BODY = {
+    statusCode: 200,
+    body: {
+        items: [RECORDING_ONE, RECORDING_TWO],
+    },
+};
+export const MOCK_EMPTY_RECORDING_LIST_BODY = {
+    statusCode: 200,
+    body: {
+        items: [],
+    },
+};
+export const MOCK_RECORDING_BODY = {
+    statusCode: 200,
+    body: RECORDING_ONE,
+};
+export const RECORDING_OWNER_ID = '8a67806f-fc4d-446b-a131-31e71ea5b0e9';
+export const RECORDING_REMOTE_PARTY_ID = '0fea4a63-4e27-46ee-99c3-2472cb12bf68';
+export const MOCK_RECORDING_METADATA = {
+    id: RECORDING_ONE.id,
+    callSessionId: CALL_SESSION_ID,
+    owner: {
+        ownerID: RECORDING_OWNER_ID,
+        ownerEmail: 'owner@cisco.com',
+        ownerName: 'Mark',
+        orgID: '1704d30d-a131-4bc7-9449-948487643793',
+    },
+    participants: [
+        { id: RECORDING_OWNER_ID, name: 'Mark', email: 'owner@cisco.com' },
+        { id: RECORDING_REMOTE_PARTY_ID, name: 'Alice', email: 'alice@cisco.com' },
+    ],
+    mediaStreams: [{ streamId: 'audio-1', type: 'audio', codec: 'opus', durationMS: 65000 }],
+    extensionData: {
+        callData: { direction: 'OUTGOING' },
+        acd: {},
+        redirectInfo: {},
+    },
+    serviceData: {
+        callRecordingId: RECORDING_ONE.id,
+        locationId: 'loc-1',
+        callSessionId: CALL_SESSION_ID,
+        personality: 'originator',
+        callingParty: {
+            actor: { type: 'USER', id: RECORDING_OWNER_ID, email: 'owner@cisco.com' },
+            number: '9902',
+            name: 'Mark',
+        },
+        calledParty: {
+            actor: { type: 'USER', id: RECORDING_REMOTE_PARTY_ID, email: 'alice@cisco.com' },
+            number: '9903',
+            name: 'Alice',
+        },
+    },
+};
+export const MOCK_RECORDING_METADATA_BODY = {
+    statusCode: 200,
+    body: MOCK_RECORDING_METADATA,
+};
+export const ERROR_DETAILS_400 = {
+    statusCode: 400,
+    data: {
+        error: '400 Bad request',
+    },
+    message: 'FAILURE',
+};
+export const ERROR_DETAILS_401 = {
+    statusCode: 401,
+    data: {
+        error: 'User is unauthorised, possible token expiry',
+    },
+    message: 'FAILURE',
+};
+export const ERROR_DETAILS_404 = {
+    statusCode: 404,
+    data: {
+        error: 'User info not found',
+    },
+    message: 'FAILURE',
+};
+const RECORDING_ACTIVITY = {
+    id: 'activity-1',
+    objectType: 'activity',
+    verb: 'add',
+    published: '2024-05-01T10:01:05.000Z',
+    actor: {
+        id: '8a67806f-fc4d-446b-a131-31e71ea5b0e9',
+        objectType: 'person',
+        emailAddress: 'owner@cisco.com',
+    },
+    object: {
+        id: RECORDING_ONE.id,
+        objectType: 'wxCallingCallRecording',
+        callSessionId: CALL_SESSION_ID,
+        durationSeconds: 65,
+        sizeBytes: 1048576,
+    },
+};
+export const MOCK_RECORDING_CREATED_EVENT = {
+    id: 'event-created',
+    data: {
+        activity: RECORDING_ACTIVITY,
+        eventType: RECORDING_EVENT_TYPE.CREATED,
+    },
+    timestamp: 12345,
+    trackingId: 'tracking-id',
+};
+export const MOCK_RECORDING_UPDATED_EVENT = {
+    id: 'event-updated',
+    data: {
+        activity: RECORDING_ACTIVITY,
+        eventType: RECORDING_EVENT_TYPE.UPDATED,
+        eventSubType: RECORDING_EVENT_SUBTYPE.SUMMARY_CREATE,
+    },
+    timestamp: 12346,
+    trackingId: 'tracking-id',
+};
+export const MOCK_RECORDING_DELETED_EVENT = {
+    id: 'event-deleted',
+    data: {
+        activity: RECORDING_ACTIVITY,
+        eventType: RECORDING_EVENT_TYPE.DELETED,
+    },
+    timestamp: 12347,
+    trackingId: 'tracking-id',
+};
+export const MOCK_RECORDING_TRASH_EVENT = {
+    id: 'event-trash',
+    data: {
+        activity: RECORDING_ACTIVITY,
+        eventType: RECORDING_EVENT_TYPE.UPDATED,
+        eventSubType: RECORDING_EVENT_SUBTYPE.TRASH,
+    },
+    timestamp: 12348,
+    trackingId: 'tracking-id',
+};
+export const MOCK_RECORDING_PURGE_EVENT = {
+    id: 'event-purge',
+    data: {
+        activity: RECORDING_ACTIVITY,
+        eventType: RECORDING_EVENT_TYPE.UPDATED,
+        eventSubType: RECORDING_EVENT_SUBTYPE.PURGE,
+    },
+    timestamp: 12349,
+    trackingId: 'tracking-id',
+};
+export const MOCK_RECORDING_RESTORE_EVENT = {
+    id: 'event-restore',
+    data: {
+        activity: RECORDING_ACTIVITY,
+        eventType: RECORDING_EVENT_TYPE.UPDATED,
+        eventSubType: RECORDING_EVENT_SUBTYPE.RESTORE,
+    },
+    timestamp: 12350,
+    trackingId: 'tracking-id',
+};
+export const RECORDING_MERCURY_KEYS = {
+    CREATED: MOBIUS_EVENT_KEYS.RECORDING_EVENT_CREATED,
+    UPDATED: MOBIUS_EVENT_KEYS.RECORDING_EVENT_UPDATED,
+    DELETED: MOBIUS_EVENT_KEYS.RECORDING_EVENT_DELETED,
+};

package/dist/module/CallRecording/constants.js

@@ -0,0 +1,28 @@
+export const CALL_RECORDING_FILE = 'CallRecording';
+export const CONVERGED_RECORDINGS = 'convergedRecordings';
+export const SOFT_DELETE = 'softDelete';
+export const METADATA = 'metadata';
+export const FROM = 'from';
+export const TO = 'to';
+export const STATUS = 'status';
+export const MAX = 'max';
+export const SERVICE_TYPE = 'serviceType';
+export const FORMAT = 'format';
+export const OWNER_TYPE = 'ownerType';
+export const STORAGE_REGION = 'storageRegion';
+export const LOCATION_ID = 'locationId';
+export const TOPIC = 'topic';
+export const DEFAULT_STATUS = 'available';
+export const DEFAULT_MAX = 30;
+export const DEFAULT_NUMBER_OF_DAYS = 30;
+export const WEBEX_USER_REQUEST_HEADER = 'WebexUserRequest';
+export const RECORDING_NOT_FOUND_MESSAGE = 'No recordings found for the given call session id.';
+export const METHODS = {
+    INITIALIZE_BACKEND_CONNECTOR: 'initializeBackendConnector',
+    GET_CALL_RECORDING: 'getCallRecording',
+    GET_RECORDINGS: 'getRecordings',
+    GET_RECORDING: 'getRecording',
+    GET_RECORDINGS_BY_CALL_SESSION_ID: 'getRecordingsByCallSessionId',
+    GET_RECORDING_METADATA: 'getRecordingMetadata',
+    DELETE_RECORDING: 'deleteRecording',
+};

package/dist/module/CallRecording/types.js

@@ -0,0 +1,19 @@
+export var RecordingStatus;
+(function (RecordingStatus) {
+    RecordingStatus["AVAILABLE"] = "available";
+    RecordingStatus["DELETED"] = "deleted";
+})(RecordingStatus || (RecordingStatus = {}));
+export var AiGenerationStatus;
+(function (AiGenerationStatus) {
+    AiGenerationStatus["NOT_STARTED"] = "NOT_STARTED";
+    AiGenerationStatus["IN_PROGRESS"] = "IN_PROGRESS";
+    AiGenerationStatus["COMPLETED"] = "COMPLETED";
+    AiGenerationStatus["FAILED"] = "FAILED";
+})(AiGenerationStatus || (AiGenerationStatus = {}));
+export var RecordingRequestType;
+(function (RecordingRequestType) {
+    RecordingRequestType["LIST"] = "list";
+    RecordingRequestType["DETAIL"] = "detail";
+    RecordingRequestType["METADATA"] = "metadata";
+    RecordingRequestType["BY_CALL_SESSION"] = "byCallSession";
+})(RecordingRequestType || (RecordingRequestType = {}));

package/dist/module/CallRecording/utils.js

@@ -0,0 +1,14 @@
+export const getRemoteParty = (serviceData) => {
+    if (!serviceData) {
+        return undefined;
+    }
+    const { personality, callingParty, calledParty } = serviceData;
+    switch (personality) {
+        case 'originator':
+            return calledParty;
+        case 'terminator':
+            return callingParty;
+        default:
+            return undefined;
+    }
+};

package/dist/module/CallingClient/CallingClient.js

@@ -1,19 +1,21 @@
 import * as Media from '@webex/internal-media-core';
 import { Mutex } from 'async-mutex';
 import { METHOD_START_MESSAGE } from '../common/constants';
-import { filterMobiusUris, handleCallingClientErrors, uploadLogs, validateServiceData, } from '../common/Utils';
+import { filterMobiusUris, handleCallingClientErrors, normalizeMobiusUris, isValidServiceDomain, uploadLogs, validateServiceData, } from '../common/Utils';
 import { LOGGER } from '../Logger/types';
 import SDKConnector from '../SDKConnector';
 import { Eventing } from '../Events/impl';
 import { MOBIUS_EVENT_KEYS, SessionType, CALLING_CLIENT_EVENT_KEYS, } from '../Events/types';
 import { ServiceIndicator, ALLOWED_SERVICES, HTTP_METHODS, RegistrationStatus, } from '../common/types';
+import { MobiusEventType } from './calling/types';
 import log from '../Logger';
 import { getCallManager } from './calling/callManager';
-import { CALLING_CLIENT_FILE, CALLS_CLEARED_HANDLER_UTIL, CALLING_USER_AGENT, CISCO_DEVICE_URL, DISCOVERY_URL, GET_MOBIUS_SERVERS_UTIL, SPARK_USER_AGENT, URL_ENDPOINT, API_V1, METHODS, NETWORK_FLAP_TIMEOUT, } from './constants';
+import { CALLING_CLIENT_FILE, CALLS_CLEARED_HANDLER_UTIL, CALLING_USER_AGENT, CISCO_DEVICE_URL, DISCOVERY_URL, GET_MOBIUS_SERVERS_UTIL, SPARK_USER_AGENT, URL_ENDPOINT, API_V1, METHODS, NETWORK_FLAP_TIMEOUT, DEVICES_ENDPOINT_RESOURCE, WCC_CALLING_RTMS_DOMAIN, } from './constants';
 import Line from './line';
-import { METRIC_EVENT, REG_ACTION, METRIC_TYPE, CONNECTION_ACTION, MOBIUS_SERVER_ACTION, } from '../Metrics/types';
+import { METRIC_EVENT, REG_ACTION, METRIC_TYPE, CONNECTION_ACTION, MOBIUS_SERVER_ACTION, MOBIUS_SOCKET_ACTION, } from '../Metrics/types';
 import { getMetricManager } from '../Metrics';
 import windowsChromiumIceWarmup from './windowsChromiumIceWarmupUtils';
+import { APIRequest } from './utils/request';
 export class CallingClient extends Eventing {
     sdkConnector;
     webex;
@@ -21,12 +23,16 @@ export class CallingClient extends Eventing {
     callManager;
     metricManager;
     sdkConfig;
+    serviceData;
     primaryMobiusUris;
     backupMobiusUris;
+    primaryWssMobiusUris;
+    backupWssMobiusUris;
     mobiusClusters;
     mobiusHost;
     mediaEngine;
     lineDict = {};
+    apiRequest;
     isNetworkDown = false;
     networkDownTimestamp = '';
     networkUpTimestamp = '';
@@ -45,14 +51,14 @@ export class CallingClient extends Eventing {
         this.mutex = new Mutex();
         this.webex = this.sdkConnector.getWebex();
         this.sdkConfig = config;
-        const serviceData = this.sdkConfig?.serviceData?.indicator
+        this.serviceData = this.sdkConfig?.serviceData?.indicator
             ? this.sdkConfig.serviceData
             : { indicator: ServiceIndicator.CALLING, domain: '' };
         const logLevel = this.sdkConfig?.logger?.level ? this.sdkConfig.logger.level : LOGGER.ERROR;
         log.setLogger(logLevel, CALLING_CLIENT_FILE);
-        validateServiceData(serviceData);
-        this.callManager = getCallManager(this.webex, serviceData.indicator);
-        this.metricManager = getMetricManager(this.webex, serviceData.indicator);
+        validateServiceData(this.serviceData);
+        this.callManager = getCallManager(this.webex, this.serviceData.indicator, this.sdkConfig?.iceGathering);
+        this.metricManager = getMetricManager(this.webex, this.serviceData.indicator);
         this.mediaEngine = Media;
         const adaptedLogger = {
             log: (...args) => webex.logger.log(args.join(' : ')),
@@ -65,12 +71,20 @@ export class CallingClient extends Eventing {
         this.mediaEngine.setLogger(adaptedLogger);
         this.primaryMobiusUris = [];
         this.backupMobiusUris = [];
+        this.primaryWssMobiusUris = [];
+        this.backupWssMobiusUris = [];
         this.mobiusClusters = this.webex.internal.services.getMobiusClusters();
         this.mobiusHost = '';
+        this.apiRequest = APIRequest.getInstance({ webex: this.webex });
         this.registerSessionsListener();
         this.registerCallsClearedListener();
     }
     async init() {
+        const loggerContext = {
+            file: CALLING_CLIENT_FILE,
+            method: METHODS.INIT,
+        };
+        log.info(METHOD_START_MESSAGE, loggerContext);
         if (typeof window !== 'undefined' && window?.navigator?.userAgent) {
             const ua = window.navigator.userAgent;
             if (ua.toLowerCase().includes('windows')) {
@@ -97,8 +111,50 @@ export class CallingClient extends Eventing {
             }
         }
         await this.getMobiusServers();
+        if (this.apiRequest.isSocketEnabled()) {
+            this.apiRequest.registerMobiusSocketConnectionListener({
+                onConnected: () => this.emit(CALLING_CLIENT_EVENT_KEYS.MOBIUS_SOCKET_CONNECTED),
+                onDisconnected: (reason) => this.emit(CALLING_CLIENT_EVENT_KEYS.MOBIUS_SOCKET_DISCONNECTED, { reason }),
+            });
+            await this.connectToMobiusSocket();
+            this.apiRequest.registerMobiusSocketListener(this.handleMobiusAsyncEvent);
+        }
+        if (this.serviceData.indicator === ServiceIndicator.CONTACT_CENTER &&
+            !this.serviceData.domain) {
+            const rtmsDomain = this.getRTMSDomain();
+            this.serviceData.domain = rtmsDomain;
+            if (this.sdkConfig?.serviceData) {
+                this.sdkConfig.serviceData.domain = this.serviceData.domain;
+            }
+        }
+        if (!isValidServiceDomain(this.serviceData)) {
+            throw new Error('Invalid service domain.');
+        }
         await this.createLine();
         this.setupNetworkEventListeners();
+        log.log('CallingClient initialization complete', loggerContext);
+    }
+    getRTMSDomain() {
+        log.info('Fetching RTMS domain from service catalog', {
+            file: CALLING_CLIENT_FILE,
+            method: METHODS.GET_RTMS_DOMAIN,
+        });
+        try {
+            const rtmsURL = this.webex.internal.services.get(WCC_CALLING_RTMS_DOMAIN);
+            const url = new URL(rtmsURL);
+            log.info(`RTMS domain resolved from catalog: ${url.hostname}`, {
+                file: CALLING_CLIENT_FILE,
+                method: METHODS.GET_RTMS_DOMAIN,
+            });
+            return url.hostname;
+        }
+        catch (error) {
+            log.warn(`Failed to fetch RTMS domain from service catalog: ${error}`, {
+                file: CALLING_CLIENT_FILE,
+                method: METHODS.GET_RTMS_DOMAIN,
+            });
+            return '';
+        }
     }
     async checkNetworkReachability() {
         try {
@@ -311,6 +367,8 @@ export class CallingClient extends Eventing {
                     const mobiusUris = filterMobiusUris(mobiusServers, this.mobiusHost);
                     this.primaryMobiusUris = mobiusUris.primary;
                     this.backupMobiusUris = mobiusUris.backup;
+                    this.primaryWssMobiusUris = mobiusUris.primaryWss;
+                    this.backupWssMobiusUris = mobiusUris.backupWss;
                     log.log(`Final list of Mobius Servers, primary: ${mobiusUris.primary} and backup: ${mobiusUris.backup}`, {
                         file: CALLING_CLIENT_FILE,
                         method: GET_MOBIUS_SERVERS_UTIL,
@@ -346,6 +404,54 @@ export class CallingClient extends Eventing {
             this.primaryMobiusUris = [`${this.mobiusHost}${URL_ENDPOINT}`];
         }
     }
+    async connectToMobiusSocket() {
+        const loggerContext = {
+            file: CALLING_CLIENT_FILE,
+            method: METHODS.CONNECT_TO_MOBIUS_SOCKET,
+        };
+        log.info(METHOD_START_MESSAGE, loggerContext);
+        if (!this.primaryWssMobiusUris.length) {
+            log.warn('No WSS URIs available from Mobius discovery for primary, skipping socket connection', loggerContext);
+            return;
+        }
+        for (const wssUri of this.primaryWssMobiusUris) {
+            try {
+                log.log(`Trying primary WSS URI: ${wssUri}`, loggerContext);
+                await this.apiRequest.connectToMobiusSocket(wssUri);
+                log.log(`Successfully connected to Mobius socket on primary WSS URI: ${wssUri}`, loggerContext);
+                return;
+            }
+            catch (err) {
+                log.warn(`Primary WSS URI connection failed for ${wssUri}: ${err}`, loggerContext);
+            }
+        }
+        log.warn('All primary WSS URI connection attempts failed', loggerContext);
+    }
+    handleMobiusAsyncEvent = async (event) => {
+        const loggerContext = {
+            file: CALLING_CLIENT_FILE,
+            method: METHODS.HANDLE_MOBIUS_ASYNC_EVENT,
+        };
+        const eventType = event?.data.eventType;
+        log.trace(`Mobius async event received - eventType: ${eventType ?? 'undefined'}`, loggerContext);
+        if (!eventType) {
+            log.warn('Dropping unsupported mobius socket payload', loggerContext);
+            return;
+        }
+        if (eventType === MobiusEventType.REGISTRATION_DOWN) {
+            log.warn(`Received ${eventType} event from Mobius.`, loggerContext);
+            const line = Object.values(this.lineDict)[0];
+            if (!line) {
+                log.warn('No line found, skipping registration down event', loggerContext);
+                return;
+            }
+            await line.registration.handleRegistrationDownEvent(event);
+            this.metricManager.submitMobiusSocketMetric(METRIC_EVENT.MOBIUS_SOCKET_ERROR, MOBIUS_SOCKET_ACTION.REGISTRATION_DOWN, METRIC_TYPE.BEHAVIORAL, undefined, event?.trackingId, undefined, eventType);
+            return;
+        }
+        this.callManager.dequeueWsEvents(event);
+        log.trace(`Mobius async event dispatched to CallManager - eventType: ${eventType}`, loggerContext);
+    };
     registerCallsClearedListener() {
         log.info(METHOD_START_MESSAGE, {
             file: CALLING_CLIENT_FILE,
@@ -404,12 +510,61 @@ export class CallingClient extends Eventing {
             file: CALLING_CLIENT_FILE,
             method: METHODS.CREATE_LINE,
         });
-        const line = new Line(this.webex.internal.device.userId, this.webex.internal.device.url, this.mutex, this.primaryMobiusUris, this.backupMobiusUris, this.getLoggingLevel(), this.sdkConfig?.serviceData, this.sdkConfig?.jwe);
+        const socketEnabled = this.apiRequest.isSocketEnabled();
+        const primaryUris = socketEnabled && this.primaryWssMobiusUris.length
+            ? normalizeMobiusUris(this.primaryWssMobiusUris)
+            : this.primaryMobiusUris;
+        const backupUris = socketEnabled && this.backupWssMobiusUris.length
+            ? normalizeMobiusUris(this.backupWssMobiusUris)
+            : this.backupMobiusUris;
+        const line = new Line(this.webex.internal.device.userId, this.webex.internal.device.url, this.mutex, primaryUris, backupUris, this.getLoggingLevel(), this.serviceData, this.sdkConfig?.jwe);
         this.lineDict[line.lineId] = line;
     }
     getLines() {
         return this.lineDict;
     }
+    async getDevices(userId) {
+        const userid = userId || this.webex.internal.device.userId;
+        if (!userid) {
+            throw new Error('userId is required to fetch devices');
+        }
+        log.info(METHOD_START_MESSAGE, { file: CALLING_CLIENT_FILE, method: METHODS.GET_DEVICES });
+        const mobiusUrls = [...this.primaryMobiusUris, ...this.backupMobiusUris];
+        if (mobiusUrls.length === 0) {
+            throw new Error('Mobius URLs are not available');
+        }
+        let finalError;
+        for (const mobiusUrl of mobiusUrls) {
+            const normalizedMobiusUrl = mobiusUrl.replace(/\/+$/, '/');
+            const uri = `${normalizedMobiusUrl}${DEVICES_ENDPOINT_RESOURCE}?userid=${encodeURIComponent(userid)}`;
+            try {
+                const response = (await this.webex.request({
+                    uri,
+                    method: HTTP_METHODS.GET,
+                    service: ALLOWED_SERVICES.MOBIUS,
+                    headers: {
+                        [CISCO_DEVICE_URL]: this.webex.internal.device.url,
+                        [SPARK_USER_AGENT]: CALLING_USER_AGENT,
+                    },
+                }));
+                if (response.statusCode !== 200) {
+                    throw new Error(`API call failed with ${response.statusCode}`);
+                }
+                const body = response.body;
+                Object.values(this.lineDict)[0].registration.setDeviceInfo(body);
+                Object.values(this.lineDict)[0].registration.setActiveMobiusUrl(normalizedMobiusUrl);
+                return body.devices ?? [];
+            }
+            catch (error) {
+                finalError = error;
+            }
+        }
+        log.error(`Failed to fetch devices for userId ${userId}: ${JSON.stringify(finalError)}`, {
+            file: CALLING_CLIENT_FILE,
+            method: METHODS.GET_DEVICES,
+        });
+        throw finalError;
+    }
     getActiveCalls() {
         const activeCalls = {};
         const calls = this.callManager.getActiveCalls();
@@ -432,6 +587,9 @@ export class CallingClient extends Eventing {
         });
         return connectCall;
     }
+    isMobiusSocketConnected() {
+        return this.apiRequest.isSocketEnabled() && this.apiRequest.isSocketConnected();
+    }
     async uploadLogs() {
         const result = await uploadLogs({}, true);
         if (!result) {