@webex/calling 3.11.0 → 3.12.0-llmrefactor.2

package/dist/module/CallingClient/registration/webWorker.js

@@ -1,73 +1,54 @@
-import { v4 as uuid } from 'uuid';
-import { HTTP_METHODS, WorkerMessageType } from '../../common/types';
+import { WorkerMessageType } from '../../common/types';
 let keepaliveTimer;
+let keepAliveRetryCount = 0;
+let keepaliveInFlight = false;
+const clearKeepaliveTimer = () => {
+    if (keepaliveTimer) {
+        clearInterval(keepaliveTimer);
+        keepaliveTimer = undefined;
+    }
+};
 const messageHandler = (event) => {
     const { type } = event.data;
-    const postKeepAlive = async (accessToken, deviceUrl, url) => {
-        const response = await fetch(`${url}/status`, {
-            method: HTTP_METHODS.POST,
-            headers: {
-                'cisco-device-url': deviceUrl,
-                'spark-user-agent': 'webex-calling/beta',
-                Authorization: `${accessToken}`,
-                trackingId: `web_worker_${uuid()}`,
-            },
-        });
-        if (!response.ok) {
-            throw response;
-        }
-        return response;
-    };
     if (type === WorkerMessageType.START_KEEPALIVE) {
-        let keepAliveRetryCount = 0;
-        const { accessToken, deviceUrl, interval, retryCountThreshold, url } = event.data;
-        if (keepaliveTimer) {
-            clearInterval(keepaliveTimer);
-            keepaliveTimer = undefined;
-        }
-        keepaliveTimer = setInterval(async () => {
-            if (keepAliveRetryCount < retryCountThreshold) {
-                try {
-                    const res = await postKeepAlive(accessToken, deviceUrl, url);
-                    const statusCode = res.status;
-                    if (keepAliveRetryCount > 0) {
-                        postMessage({
-                            type: WorkerMessageType.KEEPALIVE_SUCCESS,
-                            statusCode,
-                        });
-                    }
-                    keepAliveRetryCount = 0;
-                }
-                catch (err) {
-                    const headers = {};
-                    if (err.headers?.has('Retry-After')) {
-                        headers['retry-after'] = err.headers.get('Retry-After');
-                    }
-                    if (err.headers?.has('Trackingid')) {
-                        headers['trackingid'] = err.headers.get('Trackingid');
-                    }
-                    const error = {
-                        headers,
-                        statusCode: err.status,
-                        statusText: err.statusText,
-                        type: err.type,
-                    };
-                    keepAliveRetryCount += 1;
-                    postMessage({
-                        type: WorkerMessageType.KEEPALIVE_FAILURE,
-                        err: error,
-                        keepAliveRetryCount,
-                    });
-                }
+        const { interval, retryCountThreshold } = event.data;
+        clearKeepaliveTimer();
+        keepAliveRetryCount = 0;
+        keepaliveInFlight = false;
+        keepaliveTimer = setInterval(() => {
+            if (keepAliveRetryCount < retryCountThreshold && !keepaliveInFlight) {
+                keepaliveInFlight = true;
+                postMessage({
+                    type: WorkerMessageType.SEND_KEEPALIVE,
+                });
             }
         }, interval * 1000);
     }
-    if (type === WorkerMessageType.CLEAR_KEEPALIVE) {
-        if (keepaliveTimer) {
-            clearInterval(keepaliveTimer);
-            keepaliveTimer = undefined;
+    if (type === WorkerMessageType.KEEPALIVE_RESULT) {
+        keepaliveInFlight = false;
+        if (event.data.err === undefined) {
+            if (keepAliveRetryCount > 0) {
+                postMessage({
+                    type: WorkerMessageType.KEEPALIVE_SUCCESS,
+                    statusCode: event.data.statusCode,
+                });
+            }
+            keepAliveRetryCount = 0;
+        }
+        else {
+            keepAliveRetryCount += 1;
+            postMessage({
+                type: WorkerMessageType.KEEPALIVE_FAILURE,
+                err: event.data.err,
+                keepAliveRetryCount,
+            });
         }
     }
+    if (type === WorkerMessageType.CLEAR_KEEPALIVE) {
+        clearKeepaliveTimer();
+        keepAliveRetryCount = 0;
+        keepaliveInFlight = false;
+    }
 };
 self.addEventListener('message', messageHandler);
 export default messageHandler;

package/dist/module/CallingClient/registration/webWorkerStr.js

@@ -1,106 +1,71 @@
 const webWorkerStr = `/* eslint-env worker */
 
-const uuid = () => {
-  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
-    const r = (Math.random() * 16) | 0;
-    const v = c === 'x' ? r : (r & 0x3) | 0x8;
-    return v.toString(16);
-  });
-};
-
-// Enum values from the original imports
-const HTTP_METHODS = {
-  GET: 'GET',
-  POST: 'POST',
-  PUT: 'PUT',
-  DELETE: 'DELETE',
-  PATCH: 'PATCH',
-};
-
 const WorkerMessageType = {
   START_KEEPALIVE: 'START_KEEPALIVE',
   CLEAR_KEEPALIVE: 'CLEAR_KEEPALIVE',
+  SEND_KEEPALIVE: 'SEND_KEEPALIVE',
+  KEEPALIVE_RESULT: 'KEEPALIVE_RESULT',
   KEEPALIVE_SUCCESS: 'KEEPALIVE_SUCCESS',
   KEEPALIVE_FAILURE: 'KEEPALIVE_FAILURE',
 };
 
 let keepaliveTimer;
+let keepAliveRetryCount = 0;
+let keepaliveInFlight = false;
+
+const clearKeepaliveTimer = () => {
+  if (keepaliveTimer) {
+    clearInterval(keepaliveTimer);
+    keepaliveTimer = undefined;
+  }
+};
 
 const messageHandler = (event) => {
   const {type} = event.data;
 
-  const postKeepAlive = async (accessToken, deviceUrl, url) => {
-    const response = await fetch(\`\${url}/status\`, {
-      method: HTTP_METHODS.POST,
-      headers: {
-        'cisco-device-url': deviceUrl,
-        'spark-user-agent': 'webex-calling/beta',
-        Authorization: \`\${accessToken}\`,
-        trackingId: \`web_worker_\${uuid()}\`,
-      },
-    });
-
-    if (!response.ok) {
-      throw response;
-    }
-
-    return response;
-  };
-
   if (type === WorkerMessageType.START_KEEPALIVE) {
-    let keepAliveRetryCount = 0;
-    const {accessToken, deviceUrl, interval, retryCountThreshold, url} = event.data;
-
-    if (keepaliveTimer) {
-      clearInterval(keepaliveTimer);
-      keepaliveTimer = undefined;
-    }
-
-    keepaliveTimer = setInterval(async () => {
-      if (keepAliveRetryCount < retryCountThreshold) {
-        try {
-          const res = await postKeepAlive(accessToken, deviceUrl, url);
-          const statusCode = res.status;
-          if (keepAliveRetryCount > 0) {
-            self.postMessage({
-              type: WorkerMessageType.KEEPALIVE_SUCCESS,
-              statusCode,
-            });
-          }
-          keepAliveRetryCount = 0;
-        } catch (err) {
-          let headers = {};
-          if(err.headers?.has('Retry-After')) {
-            headers['retry-after'] = err.headers.get('Retry-After');
-          } 
-
-          if(err.headers?.has('Trackingid')) {
-            headers['trackingid'] = err.headers.get('Trackingid');
-          }   
+    const {interval, retryCountThreshold} = event.data;
+
+    clearKeepaliveTimer();
+    keepAliveRetryCount = 0;
+    keepaliveInFlight = false;
+
+    keepaliveTimer = setInterval(() => {
+      if (keepAliveRetryCount < retryCountThreshold && !keepaliveInFlight) {
+        keepaliveInFlight = true;
+        self.postMessage({
+          type: WorkerMessageType.SEND_KEEPALIVE,
+        });
+      }
+    }, interval * 1000);
+  }
 
-          const error = {
-            headers,
-            statusCode: err.status,
-            statusText: err.statusText,
-            type: err.type,
-          };
+  if (type === WorkerMessageType.KEEPALIVE_RESULT) {
+    keepaliveInFlight = false;
 
-          keepAliveRetryCount += 1
-          self.postMessage({
-            type: WorkerMessageType.KEEPALIVE_FAILURE,
-            err: error,
-            keepAliveRetryCount,
-          });
-        }
+    if (event.data.err === undefined) {
+      if (keepAliveRetryCount > 0) {
+        self.postMessage({
+          type: WorkerMessageType.KEEPALIVE_SUCCESS,
+          statusCode: event.data.statusCode,
+        });
       }
-    }, interval * 1000);
+
+      keepAliveRetryCount = 0;
+    } else {
+      keepAliveRetryCount += 1;
+      self.postMessage({
+        type: WorkerMessageType.KEEPALIVE_FAILURE,
+        err: event.data.err,
+        keepAliveRetryCount,
+      });
+    }
   }
 
   if (type === WorkerMessageType.CLEAR_KEEPALIVE) {
-    if (keepaliveTimer) {
-      clearInterval(keepaliveTimer);
-      keepaliveTimer = undefined;
-    }
+    clearKeepaliveTimer();
+    keepAliveRetryCount = 0;
+    keepaliveInFlight = false;
   }
 };
 

package/dist/module/CallingClient/utils/constants.js

@@ -0,0 +1,36 @@
+export var MOBIUS_SOCKET_MESSAGE_TYPE;
+(function (MOBIUS_SOCKET_MESSAGE_TYPE) {
+    MOBIUS_SOCKET_MESSAGE_TYPE["UNKNOWN"] = "UNKNOWN";
+    MOBIUS_SOCKET_MESSAGE_TYPE["REGISTER"] = "register";
+    MOBIUS_SOCKET_MESSAGE_TYPE["REGISTER_RESPONSE"] = "register.response";
+    MOBIUS_SOCKET_MESSAGE_TYPE["UNREGISTER"] = "unregister";
+    MOBIUS_SOCKET_MESSAGE_TYPE["UNREGISTER_RESPONSE"] = "unregister.response";
+    MOBIUS_SOCKET_MESSAGE_TYPE["DEVICE_STATUS"] = "device_status";
+    MOBIUS_SOCKET_MESSAGE_TYPE["DEVICE_STATUS_RESPONSE"] = "device_status.response";
+    MOBIUS_SOCKET_MESSAGE_TYPE["DEVICE_GET"] = "device_get";
+    MOBIUS_SOCKET_MESSAGE_TYPE["DEVICE_GET_RESPONSE"] = "device_get.response";
+    MOBIUS_SOCKET_MESSAGE_TYPE["DEVICE_LIST"] = "device_list";
+    MOBIUS_SOCKET_MESSAGE_TYPE["DEVICE_LIST_RESPONSE"] = "device_list.response";
+    MOBIUS_SOCKET_MESSAGE_TYPE["CALL_SETUP"] = "call_setup";
+    MOBIUS_SOCKET_MESSAGE_TYPE["CALL_SETUP_RESPONSE"] = "call_setup.response";
+    MOBIUS_SOCKET_MESSAGE_TYPE["CALL_STATE"] = "call_state";
+    MOBIUS_SOCKET_MESSAGE_TYPE["CALL_STATE_RESPONSE"] = "call_state.response";
+    MOBIUS_SOCKET_MESSAGE_TYPE["CALL_STATUS"] = "call_status";
+    MOBIUS_SOCKET_MESSAGE_TYPE["CALL_STATUS_RESPONSE"] = "call_status.response";
+    MOBIUS_SOCKET_MESSAGE_TYPE["CALL_MEDIA"] = "call_media";
+    MOBIUS_SOCKET_MESSAGE_TYPE["CALL_MEDIA_RESPONSE"] = "call_media.response";
+    MOBIUS_SOCKET_MESSAGE_TYPE["CALL_HOLD"] = "call_hold";
+    MOBIUS_SOCKET_MESSAGE_TYPE["CALL_HOLD_RESPONSE"] = "call_hold.response";
+    MOBIUS_SOCKET_MESSAGE_TYPE["CALL_RESUME"] = "call_resume";
+    MOBIUS_SOCKET_MESSAGE_TYPE["CALL_RESUME_RESPONSE"] = "call_resume.response";
+    MOBIUS_SOCKET_MESSAGE_TYPE["CALL_TRANSFER"] = "call_transfer";
+    MOBIUS_SOCKET_MESSAGE_TYPE["CALL_TRANSFER_RESPONSE"] = "call_transfer.response";
+    MOBIUS_SOCKET_MESSAGE_TYPE["CALL_DELETE"] = "call_delete";
+    MOBIUS_SOCKET_MESSAGE_TYPE["CALL_DELETE_RESPONSE"] = "call_delete.response";
+})(MOBIUS_SOCKET_MESSAGE_TYPE || (MOBIUS_SOCKET_MESSAGE_TYPE = {}));
+export var MOBIUS_SOCKET_DISCONNECT_REASON;
+(function (MOBIUS_SOCKET_DISCONNECT_REASON) {
+    MOBIUS_SOCKET_DISCONNECT_REASON["PERMANENT"] = "permanent";
+    MOBIUS_SOCKET_DISCONNECT_REASON["TRANSIENT"] = "transient";
+    MOBIUS_SOCKET_DISCONNECT_REASON["REPLACED"] = "replaced";
+})(MOBIUS_SOCKET_DISCONNECT_REASON || (MOBIUS_SOCKET_DISCONNECT_REASON = {}));

package/dist/module/CallingClient/utils/index.js

@@ -0,0 +1,5 @@
+export * from './request';
+export * from './types';
+export * from './mobiusSocketMapper';
+export * from './constants';
+export * from './wsFeatureFlag';

package/dist/module/CallingClient/utils/mobiusSocketMapper.js

@@ -0,0 +1,72 @@
+import { HTTP_METHODS } from '../../common/types';
+import log from '../../Logger';
+import { METHODS, MOBIUS_SOCKET_MAPPER_FILE } from '../constants';
+import { MOBIUS_SOCKET_MESSAGE_TYPE } from './constants';
+export function deriveMobiusSocketMessageType(uri, httpMethodType) {
+    const logContext = {
+        file: MOBIUS_SOCKET_MAPPER_FILE,
+        method: METHODS.DERIVE_MOBIUS_SOCKET_MESSAGE_TYPE,
+    };
+    if (!uri) {
+        log.warn('Cannot derive Mobius socket message type: uri is empty', logContext);
+        return MOBIUS_SOCKET_MESSAGE_TYPE.UNKNOWN;
+    }
+    if (uri.includes('/services')) {
+        if (uri.includes('/callhold/hold')) {
+            return MOBIUS_SOCKET_MESSAGE_TYPE.CALL_HOLD;
+        }
+        if (uri.includes('/callhold/resume')) {
+            return MOBIUS_SOCKET_MESSAGE_TYPE.CALL_RESUME;
+        }
+        if (uri.includes('/calltransfer/commit')) {
+            return MOBIUS_SOCKET_MESSAGE_TYPE.CALL_TRANSFER;
+        }
+        log.warn(`Unrecognized supplementary service uri - uri: ${uri}, httpMethod: ${httpMethodType}`, logContext);
+        return MOBIUS_SOCKET_MESSAGE_TYPE.UNKNOWN;
+    }
+    if (uri.includes('/calls/') && uri.includes('/media')) {
+        return MOBIUS_SOCKET_MESSAGE_TYPE.CALL_MEDIA;
+    }
+    if (uri.includes('/calls/') && uri.includes('/status')) {
+        return MOBIUS_SOCKET_MESSAGE_TYPE.CALL_STATUS;
+    }
+    if (uri.match(/\/calls\/[^/]+$/)) {
+        if (httpMethodType === HTTP_METHODS.PATCH) {
+            return MOBIUS_SOCKET_MESSAGE_TYPE.CALL_STATE;
+        }
+        if (httpMethodType === HTTP_METHODS.DELETE) {
+            return MOBIUS_SOCKET_MESSAGE_TYPE.CALL_DELETE;
+        }
+        log.warn(`Unrecognized httpMethod for calls/{callId} - uri: ${uri}, httpMethod: ${httpMethodType}`, logContext);
+        return MOBIUS_SOCKET_MESSAGE_TYPE.UNKNOWN;
+    }
+    if (uri.endsWith('/call')) {
+        return MOBIUS_SOCKET_MESSAGE_TYPE.CALL_SETUP;
+    }
+    if (!uri.includes('/calls/') && uri.endsWith('/status')) {
+        return MOBIUS_SOCKET_MESSAGE_TYPE.DEVICE_STATUS;
+    }
+    if (uri.endsWith('/device')) {
+        return MOBIUS_SOCKET_MESSAGE_TYPE.REGISTER;
+    }
+    if (uri.match(/\/devices\/[^/?]+$/) && !uri.includes('/calls')) {
+        if (httpMethodType === HTTP_METHODS.DELETE) {
+            return MOBIUS_SOCKET_MESSAGE_TYPE.UNREGISTER;
+        }
+        if (httpMethodType === HTTP_METHODS.GET) {
+            return MOBIUS_SOCKET_MESSAGE_TYPE.DEVICE_GET;
+        }
+        log.warn(`Unrecognized httpMethod for devices/{deviceId} - uri: ${uri}, httpMethod: ${httpMethodType}`, logContext);
+        return MOBIUS_SOCKET_MESSAGE_TYPE.UNKNOWN;
+    }
+    if (uri.includes('/devices') && !uri.match(/\/devices\/[^/?]+/)) {
+        return MOBIUS_SOCKET_MESSAGE_TYPE.DEVICE_LIST;
+    }
+    log.warn(`Unrecognized uri pattern for Mobius socket - uri: ${uri}, httpMethod: ${httpMethodType}`, logContext);
+    return MOBIUS_SOCKET_MESSAGE_TYPE.UNKNOWN;
+}
+export const isSupplementaryServiceMessageType = (type) => [
+    MOBIUS_SOCKET_MESSAGE_TYPE.CALL_HOLD,
+    MOBIUS_SOCKET_MESSAGE_TYPE.CALL_RESUME,
+    MOBIUS_SOCKET_MESSAGE_TYPE.CALL_TRANSFER,
+].includes(type);

package/dist/module/CallingClient/utils/request.js

@@ -0,0 +1,211 @@
+import { v4 as uuid } from 'uuid';
+import { getMobiusSocketInstance } from '../../mobius-socket';
+import log from '../../Logger';
+import { deriveMobiusSocketMessageType, isSupplementaryServiceMessageType, } from './mobiusSocketMapper';
+import { MOBIUS_SOCKET_DISCONNECT_REASON, MOBIUS_SOCKET_MESSAGE_TYPE } from './constants';
+import { isMobiusWssEnabled } from './wsFeatureFlag';
+import { CALLING_USER_AGENT, METHODS, REQUEST_FILE } from '../constants';
+import { getMetricManager } from '../../Metrics';
+import { METRIC_EVENT, METRIC_TYPE, MOBIUS_SOCKET_ACTION } from '../../Metrics/types';
+function normalizeWsResponse(wsResponse) {
+    return {
+        statusCode: wsResponse.statusCode,
+        body: wsResponse.data ?? undefined,
+        headers: {
+            trackingid: wsResponse.trackingId,
+            ...(wsResponse.metadata ?? {}),
+        },
+    };
+}
+function normalizeWsError(err) {
+    const wsErr = err;
+    return {
+        statusCode: wsErr.statusCode,
+        body: wsErr.response?.data ?? undefined,
+        headers: {
+            trackingid: wsErr.trackingId ?? wsErr.response?.trackingId ?? '',
+            ...(wsErr.response?.metadata ?? {}),
+        },
+    };
+}
+export class APIRequest {
+    static instance;
+    isMobiusSocketEnabled;
+    webex;
+    mobiusSocket;
+    metricManager;
+    static getInstance(config) {
+        if (!APIRequest.instance) {
+            APIRequest.instance = new APIRequest(config);
+        }
+        return APIRequest.instance;
+    }
+    static resetInstance() {
+        APIRequest.instance = undefined;
+    }
+    constructor(config) {
+        const logContext = {
+            file: REQUEST_FILE,
+            method: METHODS.CONSTRUCTOR,
+        };
+        if (!config.webex) {
+            log.error('APIRequest instantiation failed: WebexSDK instance is required', logContext);
+            throw new Error('WebexSDK instance is required');
+        }
+        this.webex = config.webex;
+        this.isMobiusSocketEnabled = isMobiusWssEnabled(config.webex) || false;
+        this.mobiusSocket = getMobiusSocketInstance(this.webex);
+        this.metricManager = getMetricManager(this.webex);
+        log.info(`APIRequest initialized with transport: ${this.isMobiusSocketEnabled ? 'WSS' : 'HTTP'}`, logContext);
+    }
+    isSocketEnabled() {
+        return this.isMobiusSocketEnabled;
+    }
+    setSocketEnabled(enabled) {
+        this.isMobiusSocketEnabled = enabled;
+        log.info(`APIRequest transport set to: ${enabled ? 'WSS' : 'HTTP'}`, {
+            file: REQUEST_FILE,
+            method: METHODS.SET_SOCKET_ENABLED,
+        });
+    }
+    async connectToMobiusSocket(wssUrl) {
+        const logContext = {
+            file: REQUEST_FILE,
+            method: METHODS.CONNECT_TO_MOBIUS_SOCKET,
+        };
+        if (this.mobiusSocket.isConnected()) {
+            log.info('Mobius WebSocket already connected', logContext);
+            return this.mobiusSocket.getConnectedWebSocketUrl();
+        }
+        log.info('Mobius WebSocket not connected, initiating connection', logContext);
+        try {
+            await this.mobiusSocket.connect(wssUrl);
+            log.log('Mobius WebSocket connected successfully', logContext);
+            this.metricManager?.submitMobiusSocketMetric(METRIC_EVENT.MOBIUS_SOCKET, MOBIUS_SOCKET_ACTION.CONNECT, METRIC_TYPE.BEHAVIORAL, wssUrl);
+            return wssUrl;
+        }
+        catch (err) {
+            log.warn(`Mobius WebSocket connection failed: ${String(err)}`, logContext);
+            this.metricManager?.submitMobiusSocketMetric(METRIC_EVENT.MOBIUS_SOCKET_ERROR, MOBIUS_SOCKET_ACTION.CONNECT, METRIC_TYPE.BEHAVIORAL, wssUrl, undefined, String(err));
+            throw normalizeWsError(err);
+        }
+    }
+    getConnectedWebSocketUrl() {
+        return this.mobiusSocket.getConnectedWebSocketUrl();
+    }
+    async disconnectFromMobiusSocket(options) {
+        const logContext = {
+            file: REQUEST_FILE,
+            method: METHODS.DISCONNECT_FROM_MOBIUS_SOCKET,
+        };
+        log.info('Disconnecting from Mobius WebSocket', logContext);
+        const wssUrl = this.mobiusSocket.getConnectedWebSocketUrl();
+        try {
+            await this.mobiusSocket.disconnect(options);
+            log.log('Mobius WebSocket disconnected successfully', logContext);
+            this.metricManager?.submitMobiusSocketMetric(METRIC_EVENT.MOBIUS_SOCKET, MOBIUS_SOCKET_ACTION.DISCONNECT, METRIC_TYPE.BEHAVIORAL, wssUrl);
+        }
+        catch (err) {
+            log.warn(`Mobius WebSocket disconnection failed: ${String(err)}`, logContext);
+            this.metricManager?.submitMobiusSocketMetric(METRIC_EVENT.MOBIUS_SOCKET_ERROR, MOBIUS_SOCKET_ACTION.DISCONNECT, METRIC_TYPE.BEHAVIORAL, wssUrl, undefined, String(err));
+        }
+    }
+    async makeRequest(request) {
+        const logContext = {
+            file: REQUEST_FILE,
+            method: METHODS.MAKE_REQUEST,
+        };
+        log.info(`Dispatching request via ${this.isMobiusSocketEnabled ? 'WSS' : 'HTTP'} `, logContext);
+        if (this.isMobiusSocketEnabled) {
+            const trackingId = `webex-js-sdk_${uuid()}`;
+            const socketType = deriveMobiusSocketMessageType(request.uri, request.method);
+            if (socketType === MOBIUS_SOCKET_MESSAGE_TYPE.UNKNOWN) {
+                log.error(`Unknown Mobius Socket message type for uri: ${request.uri}, httpMethod: ${request.method}`, logContext);
+                throw new Error(`Unknown Mobius Socket message type: ${socketType}`);
+            }
+            const isSupplementaryService = isSupplementaryServiceMessageType(socketType);
+            try {
+                const wsResponse = await this.mobiusSocket.sendWssRequest({
+                    type: socketType,
+                    trackingId,
+                    metadata: {
+                        ...request.headers,
+                        userAgent: CALLING_USER_AGENT,
+                        authorization: `${(isSupplementaryService && (await this.webex.credentials.getUserToken())) || ''}`,
+                    },
+                    data: request.body,
+                });
+                log.log(`WSS request succeeded - socketType: ${socketType}, trackingId: ${trackingId}, statusCode: ${wsResponse.statusCode}`, logContext);
+                return normalizeWsResponse(wsResponse);
+            }
+            catch (err) {
+                log.error(`WSS request failed - socketType: ${socketType}, trackingId: ${trackingId}, error: ${String(err)}`, logContext);
+                throw normalizeWsError(err);
+            }
+        }
+        return this.webex.request(request);
+    }
+    registerMobiusSocketListener(cb) {
+        const logContext = {
+            file: REQUEST_FILE,
+            method: METHODS.REGISTER_MOBIUS_SOCKET_LISTENER,
+        };
+        log.info('Attaching Mobius async event listener', logContext);
+        this.mobiusSocket.on('event:async_event', (data) => {
+            log.trace(`Mobius async event received - eventType: ${data?.data?.eventType ?? 'unknown'}`, logContext);
+            cb(data);
+        });
+        log.log('Mobius async event listener attached', logContext);
+        this.metricManager?.submitMobiusSocketMetric(METRIC_EVENT.MOBIUS_SOCKET, MOBIUS_SOCKET_ACTION.LISTENER_REGISTERED, METRIC_TYPE.BEHAVIORAL);
+    }
+    unregisterMobiusSocketListener() {
+        const logContext = {
+            file: REQUEST_FILE,
+            method: METHODS.UNREGISTER_MOBIUS_SOCKET_LISTENER,
+        };
+        log.info('Detaching Mobius async event listener', logContext);
+        this.mobiusSocket.off('event:async_event');
+        log.log('Mobius async event listener detached', logContext);
+        this.metricManager?.submitMobiusSocketMetric(METRIC_EVENT.MOBIUS_SOCKET, MOBIUS_SOCKET_ACTION.LISTENER_UNREGISTERED, METRIC_TYPE.BEHAVIORAL);
+    }
+    registerMobiusSocketConnectionListener(listener) {
+        const logContext = {
+            file: REQUEST_FILE,
+            method: METHODS.REGISTER_MOBIUS_SOCKET_CONNECTION_LISTENER,
+        };
+        log.info('Attaching Mobius socket connection listener', logContext);
+        this.mobiusSocket.on('online', () => {
+            log.log('Mobius socket connected', logContext);
+            listener.onConnected();
+        });
+        this.mobiusSocket.on('offline.permanent', () => {
+            log.log('Mobius socket disconnected (permanent)', logContext);
+            listener.onDisconnected(MOBIUS_SOCKET_DISCONNECT_REASON.PERMANENT);
+        });
+        this.mobiusSocket.on('offline.transient', () => {
+            log.log('Mobius socket disconnected (transient)', logContext);
+            listener.onDisconnected(MOBIUS_SOCKET_DISCONNECT_REASON.TRANSIENT);
+        });
+        this.mobiusSocket.on('offline.replaced', () => {
+            log.log('Mobius socket disconnected (replaced)', logContext);
+            listener.onDisconnected(MOBIUS_SOCKET_DISCONNECT_REASON.REPLACED);
+        });
+        log.log('Mobius socket connection listener attached', logContext);
+    }
+    isSocketConnected() {
+        return this.mobiusSocket.isConnected();
+    }
+    unregisterMobiusSocketConnectionListener() {
+        const logContext = {
+            file: REQUEST_FILE,
+            method: METHODS.UNREGISTER_MOBIUS_SOCKET_CONNECTION_LISTENER,
+        };
+        log.info('Detaching Mobius socket connection listener', logContext);
+        this.mobiusSocket.off('online');
+        this.mobiusSocket.off('offline.permanent');
+        this.mobiusSocket.off('offline.transient');
+        this.mobiusSocket.off('offline.replaced');
+        log.log('Mobius socket connection listener detached', logContext);
+    }
+}
+export const createAPIRequest = (config) => APIRequest.getInstance(config);

package/dist/module/CallingClient/utils/types.js

@@ -0,0 +1 @@
+export {};

package/dist/module/CallingClient/utils/wsFeatureFlag.js

@@ -0,0 +1,41 @@
+import log from '../../Logger';
+import { METHODS, WS_FEATURE_FLAG_FILE } from '../constants';
+export const WEBRTC_CALLING_OVER_WS_FEATURE_KEY = 'webrtc-calling-over-ws-CALL-219562';
+const ALLOWED_ORIGINS = ['localhost', '127.0.0.1', 'web-sdk.webex.com'];
+function samplesPageToggleValue() {
+    if (typeof window === 'undefined' || !window.localStorage) {
+        return null;
+    }
+    const hostname = window.location.hostname;
+    const isAllowedOrigin = ALLOWED_ORIGINS.some((origin) => hostname === origin || hostname.endsWith(`.${origin}`));
+    if (!isAllowedOrigin) {
+        return null;
+    }
+    const localStorageValue = localStorage.getItem('mobius-wss-enabled');
+    if (localStorageValue === 'true') {
+        log.trace(`Mobius WSS force-enabled via samples page localStorage override on ${hostname}`, {
+            file: WS_FEATURE_FLAG_FILE,
+            method: METHODS.IS_MOBIUS_WSS_ENABLED,
+        });
+        return true;
+    }
+    if (localStorageValue === 'false') {
+        log.trace(`Mobius WSS force-disabled via samples page localStorage override on ${hostname}`, {
+            file: WS_FEATURE_FLAG_FILE,
+            method: METHODS.IS_MOBIUS_WSS_ENABLED,
+        });
+        return false;
+    }
+    return null;
+}
+export function isMobiusWssEnabled(webex) {
+    const enabled = webex.internal?.device?.features?.developer?.get(WEBRTC_CALLING_OVER_WS_FEATURE_KEY)?.value ===
+        true;
+    const localStorageOverride = samplesPageToggleValue();
+    const finalValue = localStorageOverride !== null ? localStorageOverride : enabled;
+    log.trace(`Mobius WSS feature flag '${WEBRTC_CALLING_OVER_WS_FEATURE_KEY}' resolved to: ${finalValue} (backend: ${enabled}, localStorage: ${localStorageOverride})`, {
+        file: WS_FEATURE_FLAG_FILE,
+        method: METHODS.IS_MOBIUS_WSS_ENABLED,
+    });
+    return finalValue;
+}

package/dist/module/Contacts/ContactsClient.js

@@ -283,7 +283,7 @@ export class ContactsClient {
             return this.encryptionKeyUrl;
         }
         if (this.groups === undefined) {
-            this.getContacts();
+            await this.getContacts();
         }
         if (this.groups && this.groups.length) {
             return this.groups[0].encryptionKeyUrl;

package/dist/module/Errors/types.js

@@ -12,6 +12,7 @@ export var ERROR_TYPE;
     ERROR_TYPE["NOT_FOUND"] = "not_found";
     ERROR_TYPE["REGISTRATION_ERROR"] = "registration_error";
     ERROR_TYPE["SERVICE_UNAVAILABLE"] = "service_unavailable";
+    ERROR_TYPE["SESSION_SUPERSEDED"] = "session_superseded";
     ERROR_TYPE["TIMEOUT"] = "timeout";
     ERROR_TYPE["TOKEN_ERROR"] = "token_error";
     ERROR_TYPE["TOO_MANY_REQUESTS"] = "too_many_requests";
@@ -22,6 +23,7 @@ export var ERROR_CODE;
     ERROR_CODE[ERROR_CODE["UNAUTHORIZED"] = 401] = "UNAUTHORIZED";
     ERROR_CODE[ERROR_CODE["FORBIDDEN"] = 403] = "FORBIDDEN";
     ERROR_CODE[ERROR_CODE["DEVICE_NOT_FOUND"] = 404] = "DEVICE_NOT_FOUND";
+    ERROR_CODE[ERROR_CODE["CONFLICT"] = 409] = "CONFLICT";
     ERROR_CODE[ERROR_CODE["INTERNAL_SERVER_ERROR"] = 500] = "INTERNAL_SERVER_ERROR";
     ERROR_CODE[ERROR_CODE["NOT_IMPLEMENTED"] = 501] = "NOT_IMPLEMENTED";
     ERROR_CODE[ERROR_CODE["SERVICE_UNAVAILABLE"] = 503] = "SERVICE_UNAVAILABLE";