@webex/contact-center 3.12.0-next.12 → 3.12.0-next.121

package/src/cc.ts

@@ -25,6 +25,7 @@ import {
   UploadLogsResponse,
   UpdateDeviceTypeResponse,
   GenericError,
+  ConfigFlags,
 } from './types';
 import {
   READY,
@@ -55,6 +56,10 @@ import {
 import {ConnectionLostDetails} from './services/core/websocket/types';
 import TaskManager from './services/task/TaskManager';
 import WebCallingService from './services/WebCallingService';
+import AnswerCallOnWebexService from './services/AnswerCallOnWebexService';
+import WebexCrossClientService from './services/WebexCrossClientService';
+import WxAppTelephonyMercurySync from './services/WxAppTelephonyMercurySync';
+import {logWxAppSessionReadiness} from './services/wxAppDiagnosticLogging';
 import {
   ITask,
   TASK_EVENTS,
@@ -69,6 +74,7 @@ import {EntryPoint} from './services/EntryPoint';
 import {AddressBook} from './services/AddressBook';
 import {Queue} from './services/Queue';
 import {ApiAIAssistant} from './services/ApiAiAssistant';
+import {UserPreference} from './services/UserPreference';
 import type {
   EntryPointListResponse,
   EntryPointSearchParams,
@@ -230,6 +236,34 @@ export default class ContactCenter extends WebexPlugin implements IContactCenter
    */
   private webCallingService: WebCallingService;
 
+  /**
+   * REST telephony for wxApp thick-client answer (WXCC-6026)
+   * @private
+   */
+  private answerCallOnWebexService: AnswerCallOnWebexService;
+
+  /**
+   * usersub cross-client state for Webex App toast suppression
+   * @private
+   */
+  private webexCrossClientService: WebexCrossClientService;
+
+  /**
+   * Mercury telephony mute sync for wxApp thick-client answer
+   * @private
+   */
+  private wxAppTelephonyMercurySync: WxAppTelephonyMercurySync;
+
+  /** True when wxApp mute sync opened Mercury (Extension/DN-only profiles). */
+  private wxAppMercuryConnectedByCc = false;
+
+  /** True when wxApp mute sync registered the Webex device. */
+  private wxAppDeviceRegisteredByCc = false;
+
+  private static readonly WXAPP_FALSE_PUBLISH_RETRY_DELAY_MS = 30_000;
+  private static readonly WXAPP_FALSE_PUBLISH_MAX_RETRIES = 3;
+  private wxAppFalsePublishRetryTimer?: ReturnType<typeof setTimeout>;
+
   /**
    * Core service managers for Contact Center operations
    * Includes agent, connection, and configuration services
@@ -325,7 +359,38 @@ export default class ContactCenter extends WebexPlugin implements IContactCenter
    * });
    * ```
    */
-  private queue: Queue;
+  public queue: Queue;
+
+  /**
+   * API instance for managing Webex Contact Center user preferences
+   * Provides functionality to get, create, update, and delete user preferences
+   * @type {UserPreference}
+   * @public
+   * @example
+   * ```typescript
+   * const cc = webex.cc;
+   * await cc.register();
+   * await cc.stationLogin({ teamId: 'team123', loginOption: 'BROWSER' });
+   *
+   * // Get user preferences for current user
+   * const preferences = await cc.userPreference.getUserPreference();
+   *
+   * // Create new user preferences
+   * const newPrefs = await cc.userPreference.createUserPreference({
+   *   userId: 'user123',
+   *   preferences: { e911Reminder: true }
+   * });
+   *
+   * // Update user preferences
+   * const updatedPrefs = await cc.userPreference.updateUserPreference('user123', {
+   *   preferences: { e911Reminder: false }
+   * });
+   *
+   * // Delete user preferences
+   * await cc.userPreference.deleteUserPreference('user123');
+   * ```
+   */
+  public userPreference: UserPreference;
 
   /**
    * API instance for AI Assistant operations such as transcript controls.
@@ -357,6 +422,7 @@ export default class ContactCenter extends WebexPlugin implements IContactCenter
     this.$webex.once(READY, () => {
       // @ts-ignore
       this.$config = this.config;
+      this.validatePluginConfig();
 
       /**
        * This is used for handling the async requests by sending webex.request and wait for corresponding websocket event.
@@ -369,17 +435,21 @@ export default class ContactCenter extends WebexPlugin implements IContactCenter
         webex: this.$webex,
         connectionConfig: this.getConnectionConfig(),
       });
-      this.services.webSocketManager.on('message', this.handleWebsocketMessage);
 
       this.webCallingService = new WebCallingService(this.$webex);
+      this.answerCallOnWebexService = new AnswerCallOnWebexService(this.$webex);
+      this.webexCrossClientService = new WebexCrossClientService(this.$webex);
+      this.wxAppTelephonyMercurySync = new WxAppTelephonyMercurySync(this.$webex);
       this.apiAIAssistant = new ApiAIAssistant(this.$webex);
       this.metricsManager = MetricsManager.getInstance({webex: this.$webex});
       this.taskManager = TaskManager.getTaskManager(
         this.apiAIAssistant,
         this.services.contact,
         this.webCallingService,
-        this.services.webSocketManager
+        this.services.webSocketManager,
+        this.services.rtdWebSocketManager
       );
+      this.taskManager.setAnswerCallOnWebexService(this.answerCallOnWebexService);
       this.incomingTaskListener();
 
       // Initialize API instances
@@ -387,6 +457,7 @@ export default class ContactCenter extends WebexPlugin implements IContactCenter
       this.entryPoint = new EntryPoint(this.$webex);
       this.addressBook = new AddressBook(this.$webex, () => this.agentConfig?.addressBookId);
       this.queue = new Queue(this.$webex);
+      this.userPreference = new UserPreference(this.$webex, () => this.agentConfig?.agentId);
       LoggerProxy.initialize(this.$webex.logger);
     });
   }
@@ -411,6 +482,16 @@ export default class ContactCenter extends WebexPlugin implements IContactCenter
     this.trigger(TASK_EVENTS.TASK_HYDRATE, task);
   };
 
+  /**
+   * Handles multi-login hydrate events for SDK instances without Mobius registration
+   * @private
+   * @param {ITask} task The task object associated with the multi-login hydrate
+   */
+  private handleTaskMultiLoginHydrate = (task: ITask) => {
+    // @ts-ignore
+    this.trigger(TASK_EVENTS.TASK_MULTI_LOGIN_HYDRATE, task);
+  };
+
   /**
    * Handles task merged events when tasks are combined eg: EPDN merge/transfer
    * @private
@@ -431,8 +512,8 @@ export default class ContactCenter extends WebexPlugin implements IContactCenter
     this.trigger(TASK_EVENTS.TASK_CAMPAIGN_PREVIEW_RESERVATION, task);
   };
 
-  private handleRTDWebsocketMessage = (payload: string) => {
-    this.taskManager.handleRealtimeWebsocketEvent(payload);
+  private handleRTDWebsocketMessage = (event: string) => {
+    this.taskManager.handleRealtimeWebsocketEvent(event);
   };
 
   /**
@@ -443,6 +524,7 @@ export default class ContactCenter extends WebexPlugin implements IContactCenter
   private incomingTaskListener() {
     this.taskManager.on(TASK_EVENTS.TASK_INCOMING, this.handleIncomingTask);
     this.taskManager.on(TASK_EVENTS.TASK_HYDRATE, this.handleTaskHydrate);
+    this.taskManager.on(TASK_EVENTS.TASK_MULTI_LOGIN_HYDRATE, this.handleTaskMultiLoginHydrate);
     this.taskManager.on(TASK_EVENTS.TASK_MERGED, this.handleTaskMerged);
     this.taskManager.on(
       TASK_EVENTS.TASK_CAMPAIGN_PREVIEW_RESERVATION,
@@ -487,7 +569,7 @@ export default class ContactCenter extends WebexPlugin implements IContactCenter
    * ```
    */
   public async register(): Promise<Profile> {
-    LoggerProxy.info('Starting CC SDK registration', {
+    LoggerProxy.log('Starting CC SDK registration', {
       module: CC_FILE,
       method: METHODS.REGISTER,
     });
@@ -497,6 +579,7 @@ export default class ContactCenter extends WebexPlugin implements IContactCenter
         METRIC_EVENT_NAMES.WEBSOCKET_REGISTER_FAILED,
       ]);
       this.setupEventListeners();
+      this.services.webSocketManager.on('message', this.handleWebsocketMessage);
 
       const resp = await this.connectWebsocket();
       // Ensure 'dn' is always populated from 'defaultDn'
@@ -576,6 +659,7 @@ export default class ContactCenter extends WebexPlugin implements IContactCenter
 
       this.taskManager.off(TASK_EVENTS.TASK_INCOMING, this.handleIncomingTask);
       this.taskManager.off(TASK_EVENTS.TASK_HYDRATE, this.handleTaskHydrate);
+      this.taskManager.off(TASK_EVENTS.TASK_MULTI_LOGIN_HYDRATE, this.handleTaskMultiLoginHydrate);
       this.taskManager.off(
         TASK_EVENTS.TASK_CAMPAIGN_PREVIEW_RESERVATION,
         this.handleCampaignPreviewReservation
@@ -586,6 +670,10 @@ export default class ContactCenter extends WebexPlugin implements IContactCenter
       this.services.rtdWebSocketManager.off('message', this.handleRTDWebsocketMessage);
       this.services.connectionService.off('connectionLost', this.handleConnectionLost);
 
+      const {publishError: wxAppPublishError} = await this.teardownWxAppLocalState({
+        clearInitFlag: true,
+      });
+
       if (
         this.agentConfig.webRtcEnabled &&
         this.agentConfig.loginVoiceOptions.includes(LoginOption.BROWSER)
@@ -606,6 +694,9 @@ export default class ContactCenter extends WebexPlugin implements IContactCenter
       if (!this.services.webSocketManager.isSocketClosed) {
         this.services.webSocketManager.close(false, 'Unregistering the SDK');
       }
+      if (this.services.rtdWebSocketManager && !this.services.rtdWebSocketManager.isSocketClosed) {
+        this.services.rtdWebSocketManager.close(false, 'Unregistering the SDK');
+      }
 
       if (this.services.rtdWebSocketManager && !this.services.rtdWebSocketManager.isSocketClosed) {
         this.services.rtdWebSocketManager.close(false, 'Unregistering the RTD websocket');
@@ -614,6 +705,10 @@ export default class ContactCenter extends WebexPlugin implements IContactCenter
       // Clear any cached agent configuration
       this.agentConfig = null;
 
+      if (wxAppPublishError) {
+        throw wxAppPublishError;
+      }
+
       LoggerProxy.log('Deregistered successfully', {
         module: CC_FILE,
         method: METHODS.DEREGISTER,
@@ -676,6 +771,9 @@ export default class ContactCenter extends WebexPlugin implements IContactCenter
    * ```
    */
   public async getBuddyAgents(data: BuddyAgents): Promise<BuddyAgentsResponse> {
+    const {action, state, mediaType = 'telephony'} = data;
+    const buddyAgentState = state ?? (action === 'Transfer' ? AGENT_STATE_AVAILABLE : undefined);
+
     LoggerProxy.info('Fetching buddy agents', {
       module: CC_FILE,
       method: METHODS.GET_BUDDY_AGENTS,
@@ -686,15 +784,19 @@ export default class ContactCenter extends WebexPlugin implements IContactCenter
         METRIC_EVENT_NAMES.FETCH_BUDDY_AGENTS_FAILED,
       ]);
       const resp = await this.services.agent.buddyAgents({
-        data: {agentProfileId: this.agentConfig.agentProfileID, ...data},
+        data: {
+          agentProfileId: this.agentConfig.agentProfileID,
+          mediaType,
+          ...(buddyAgentState ? {state: buddyAgentState} : {}),
+        },
       });
 
       this.metricsManager.trackEvent(
         METRIC_EVENT_NAMES.FETCH_BUDDY_AGENTS_SUCCESS,
         {
           ...MetricsManager.getCommonTrackingFieldForAQMResponse(resp),
-          mediaType: data.mediaType,
-          buddyAgentState: data.state,
+          mediaType,
+          buddyAgentState,
           buddyAgentCount: resp.data.agentList.length,
         },
         ['operational']
@@ -714,8 +816,8 @@ export default class ContactCenter extends WebexPlugin implements IContactCenter
         METRIC_EVENT_NAMES.FETCH_BUDDY_AGENTS_FAILED,
         {
           ...MetricsManager.getCommonTrackingFieldForAQMResponseFailed(failureResp),
-          mediaType: data.mediaType,
-          buddyAgentState: data.state,
+          mediaType,
+          buddyAgentState,
         },
         ['operational']
       );
@@ -731,7 +833,7 @@ export default class ContactCenter extends WebexPlugin implements IContactCenter
    * @private
    */
   private async connectWebsocket() {
-    LoggerProxy.info('Connecting to websocket', {
+    LoggerProxy.log('Connecting to websocket', {
       module: CC_FILE,
       method: METHODS.CONNECT_WEBSOCKET,
     });
@@ -751,19 +853,41 @@ export default class ContactCenter extends WebexPlugin implements IContactCenter
         method: METHODS.CONNECT_WEBSOCKET,
       });
 
+      const configFlags: ConfigFlags = {
+        isEndTaskEnabled: this.agentConfig.isEndTaskEnabled,
+        isEndConsultEnabled: this.agentConfig.isEndConsultEnabled,
+        webRtcEnabled: this.agentConfig.webRtcEnabled,
+        autoWrapup: this.agentConfig.wrapUpData?.wrapUpProps?.autoWrapup ?? false,
+        aiFeature: this.agentConfig.aiFeature,
+        consultTransfer: {
+          allowConsultToQueue: this.agentConfig.allowConsultToQueue,
+          accessQueue: this.agentConfig.accessQueue,
+          accessEntryPoint: this.agentConfig.accessEntryPoint,
+          accessBuddyTeam: this.agentConfig.accessBuddyTeam,
+        },
+        enableWxBetterTogether: this.isWxBetterTogetherEnabled(),
+      };
+      this.taskManager.setConfigFlags(configFlags);
       // TODO: Make profile a singleton to make it available throughout app/sdk so we dont need to inject info everywhere
       this.taskManager.setWrapupData(this.agentConfig.wrapUpData);
       this.taskManager.setAgentId(this.agentConfig.agentId);
       this.taskManager.setWebRtcEnabled(this.agentConfig.webRtcEnabled);
       this.apiAIAssistant.setAIFeatureFlags(this.agentConfig.aiFeature);
 
-      if (this.agentConfig.aiFeature?.realtimeTranscripts?.enable) {
+      /**
+       * RTD websocket currently supports realtime transcripts and suggested responses.
+       * Extend this condition when additional AI RTD features are introduced.
+       */
+      if (
+        this.agentConfig.aiFeature?.realtimeTranscripts?.enable ||
+        this.agentConfig.aiFeature?.suggestedResponses?.enable
+      ) {
         LoggerProxy.info('Connecting to RTD websocket', {
           module: CC_FILE,
           method: METHODS.CONNECT_WEBSOCKET,
         });
 
-        await this.services.rtdWebSocketManager
+        this.services.rtdWebSocketManager
           .initWebSocket({
             body: this.getConnectionConfig(),
             resource: RTD_SUBSCRIBE_API,
@@ -776,7 +900,7 @@ export default class ContactCenter extends WebexPlugin implements IContactCenter
             this.services.rtdWebSocketManager.on('message', this.handleRTDWebsocketMessage);
           })
           .catch((error) => {
-            LoggerProxy.error(`Error during RTD websocket setup: ${error}`, {
+            LoggerProxy.error(`Error connecting to RTD websocket ${error}`, {
               module: CC_FILE,
               method: METHODS.CONNECT_WEBSOCKET,
             });
@@ -785,7 +909,8 @@ export default class ContactCenter extends WebexPlugin implements IContactCenter
 
       if (
         this.agentConfig.webRtcEnabled &&
-        this.agentConfig.loginVoiceOptions.includes(LoginOption.BROWSER)
+        this.agentConfig.loginVoiceOptions.includes(LoginOption.BROWSER) &&
+        !this.isWebRTCRegistrationDisabled()
       ) {
         try {
           await this.$webex.internal.mercury.connect();
@@ -799,10 +924,23 @@ export default class ContactCenter extends WebexPlugin implements IContactCenter
             method: METHODS.CONNECT_WEBSOCKET,
           });
         }
+      } else if (this.isWebRTCRegistrationDisabled()) {
+        LoggerProxy.info(
+          'Skipping Mobius registration because disableWebRTCRegistration is enabled',
+          {
+            module: CC_FILE,
+            method: METHODS.CONNECT_WEBSOCKET,
+          }
+        );
       }
 
       if (this.$config && this.$config.allowAutomatedRelogin) {
         await this.silentRelogin();
+      } else {
+        LoggerProxy.log('Skipping silent relogin: allowAutomatedRelogin is disabled', {
+          module: CC_FILE,
+          method: METHODS.CONNECT_WEBSOCKET,
+        });
       }
 
       return this.agentConfig;
@@ -845,36 +983,48 @@ export default class ContactCenter extends WebexPlugin implements IContactCenter
    * ```
    */
   public async stationLogin(data: AgentLogin): Promise<StationLoginResponse> {
-    LoggerProxy.info('Starting agent station login', {
-      module: CC_FILE,
-      method: METHODS.STATION_LOGIN,
-    });
+    const loggerContext = {module: CC_FILE, method: METHODS.STATION_LOGIN};
+
     try {
+      LoggerProxy.log(
+        `Starting agent station login | loginOption: ${data?.loginOption} teamId: ${data?.teamId}`,
+        loggerContext
+      );
       this.metricsManager.timeEvent([
         METRIC_EVENT_NAMES.STATION_LOGIN_SUCCESS,
         METRIC_EVENT_NAMES.STATION_LOGIN_FAILED,
       ]);
 
       const dialPlanEntries = this.agentConfig?.dialPlan?.dialPlanEntity ?? [];
-      if (
-        data.loginOption === LoginOption.AGENT_DN &&
-        !isValidDialNumber(data.dialNumber, dialPlanEntries)
-      ) {
-        const error = new Error('INVALID_DIAL_NUMBER');
-        // @ts-ignore - adding custom key to the error object
-        error.details = {data: {reason: 'INVALID_DIAL_NUMBER'}} as Failure;
+      if (data.loginOption === LoginOption.AGENT_DN) {
+        LoggerProxy.log(
+          `Validating dial number | dialPlanEnabled: ${!!this.agentConfig
+            ?.dialPlan} | dialPlanEntryCount: ${dialPlanEntries.length}`,
+          loggerContext
+        );
 
-        throw error;
+        if (!isValidDialNumber(data.dialNumber, dialPlanEntries)) {
+          LoggerProxy.log(
+            `Dial number validation failed | dialNumber: ${data.dialNumber} | dialPlanEntryCount: ${dialPlanEntries.length}`,
+            loggerContext
+          );
+          const error = new Error('INVALID_DIAL_NUMBER');
+          // @ts-ignore - adding custom key to the error object
+          error.details = {data: {reason: 'INVALID_DIAL_NUMBER'}} as Failure;
+
+          throw error;
+        }
       }
 
+      const deviceId = this.getDeviceId(data.loginOption, data.dialNumber);
       const loginResponse = await this.services.agent.stationLogin({
         data: {
-          dialNumber:
-            data.loginOption === LoginOption.BROWSER ? this.agentConfig.agentId : data.dialNumber,
+          // BROWSER DN must be webrtc-{agentId} so VPOP/RTMS do not treat a bare UUID as PSTN.
+          dialNumber: data.loginOption === LoginOption.BROWSER ? deviceId : data.dialNumber,
           teamId: data.teamId,
           deviceType: data.loginOption,
           isExtension: data.loginOption === LoginOption.EXTENSION,
-          deviceId: this.getDeviceId(data.loginOption, data.dialNumber),
+          deviceId,
           roles: [AGENT],
           teamName: EMPTY_STRING,
           siteId: EMPTY_STRING,
@@ -883,8 +1033,24 @@ export default class ContactCenter extends WebexPlugin implements IContactCenter
         },
       });
 
-      if (this.agentConfig.webRtcEnabled && data.loginOption === LoginOption.BROWSER) {
+      if (
+        this.agentConfig.webRtcEnabled &&
+        data.loginOption === LoginOption.BROWSER &&
+        !this.isWebRTCRegistrationDisabled()
+      ) {
         await this.webCallingService.registerWebCallingLine();
+      } else if (
+        this.agentConfig.webRtcEnabled &&
+        data.loginOption === LoginOption.BROWSER &&
+        this.isWebRTCRegistrationDisabled()
+      ) {
+        LoggerProxy.info(
+          'Skipping web calling line registration because disableWebRTCRegistration is enabled',
+          {
+            module: CC_FILE,
+            method: METHODS.STATION_LOGIN,
+          }
+        );
       }
 
       const resp = await loginResponse;
@@ -902,6 +1068,16 @@ export default class ContactCenter extends WebexPlugin implements IContactCenter
       };
 
       this.webCallingService.setLoginOption(data.loginOption);
+      if (this.agentConfig) {
+        this.agentConfig.deviceType = data.loginOption;
+        if (
+          data.loginOption === LoginOption.AGENT_DN ||
+          data.loginOption === LoginOption.EXTENSION
+        ) {
+          this.agentConfig.defaultDn = data.dialNumber;
+          this.agentConfig.dn = data.dialNumber;
+        }
+      }
       this.metricsManager.trackEvent(
         METRIC_EVENT_NAMES.STATION_LOGIN_SUCCESS,
         {
@@ -923,6 +1099,8 @@ export default class ContactCenter extends WebexPlugin implements IContactCenter
         }
       );
 
+      await this.ensureWxAppPostStationLogin();
+
       return response;
     } catch (error) {
       const failure = error.details as Failure;
@@ -991,6 +1169,8 @@ export default class ContactCenter extends WebexPlugin implements IContactCenter
         this.webCallingService.deregisterWebCallingLine();
       }
 
+      await this.teardownWxAppLocalState();
+
       LoggerProxy.log(`Agent station logout completed successfully`, {
         module: CC_FILE,
         method: METHODS.STATION_LOGOUT,
@@ -1246,6 +1426,600 @@ export default class ContactCenter extends WebexPlugin implements IContactCenter
     }
   };
 
+  /**
+   * Checks whether Mobius/WebRTC registration should be skipped by config
+   * @returns {boolean} True when browser WebRTC registration is disabled
+   * @private
+   */
+  private isWebRTCRegistrationDisabled(): boolean {
+    return this.$config?.disableWebRTCRegistration === true;
+  }
+
+  /**
+   * Validates contact-center plugin configuration before service initialization
+   * @private
+   */
+  private validatePluginConfig(): void {
+    if (
+      this.$config?.disableWebRTCRegistration === true &&
+      this.$config?.allowMultiLogin === false
+    ) {
+      throw new Error(
+        'Invalid Contact Center configuration: disableWebRTCRegistration cannot be true when allowMultiLogin is false. Enable allowMultiLogin or allow WebRTC registration so an SDK instance can receive Mobius/WebRTC task events.'
+      );
+    }
+  }
+
+  /**
+   * Whether wxApp thick-client answer is enabled for this SDK instance.
+   * @public
+   */
+  public isWxBetterTogetherEnabled(): boolean {
+    return this.$config?.enableWxBetterTogether === true;
+  }
+
+  /**
+   * Current station login option (Extension, Dial Number, or Browser/Desktop).
+   * Prefer webCallingService — updated on every stationLogin before wxApp hooks run.
+   * @private
+   */
+  private getCurrentStationLoginOption(): LoginOption | undefined {
+    return this.webCallingService?.loginOption ?? this.agentConfig?.deviceType;
+  }
+
+  /**
+   * wxApp thick-client answer is supported for Extension and Dial Number station login only —
+   * not Browser/Desktop (WebRTC) login.
+   * @private
+   */
+  private assertWxAppStationLoginSupportedForEnable(): void {
+    const loginOption = this.getCurrentStationLoginOption();
+    if (loginOption !== LoginOption.EXTENSION && loginOption !== LoginOption.AGENT_DN) {
+      throw new Error(
+        'setManageWebexCallingInWxcc requires EXTENSION or AGENT_DN station login. Complete station login before enabling.'
+      );
+    }
+  }
+
+  /**
+   * Clears runtime wxApp config after logout/deregister so stale flags do not apply on relogin.
+   * @private
+   */
+  private resetEnableWxBetterTogetherConfig(): void {
+    if (this.$config) {
+      this.$config.enableWxBetterTogether = false;
+    }
+    this.taskManager.applyEnableWxBetterTogether(false);
+  }
+
+  /**
+   * Runtime enable/disable for wxApp Better Together (toast suppression + Mercury mute sync).
+   *
+   * **Phase 1 (WXCC-6026 / MMT): NOT part of the public host contract.**
+   * Hosts must set `webexConfig.cc.enableWxBetterTogether` before `webex.init()` / `cc.register()`.
+   * To change the flag after the SDK is initialized, re-init the SDK with the updated config.
+   *
+   * **Supported public read API:** {@link isWxBetterTogetherEnabled}.
+   * **Supported telephony API:** unified `task.accept()`, `task.decline()`, `task.toggleMute()`,
+   * `task.transmitDtmf()` — SDK routes wxApp calls internally when the init flag is active.
+   *
+   * **Production lifecycle does not call this method.** Station login, silent relogin, logout,
+   * and deregister use {@link ensureWxAppPostStationLogin} and {@link teardownWxAppLocalState}
+   * (usersub publish + Mercury subscribe/unsubscribe based on the init flag).
+   *
+   * This setter remains as a **private implementation** for Phase 2 runtime toggle and unit tests.
+   * It updates `$config.enableWxBetterTogether`, TaskManager flags, cross-client usersub
+   * (`answer-calls-on-wxcc`), and Mercury mute sync; rolls back config on publish/connect failure.
+   *
+   * @param enabled - `true` to enable wxApp answer + usersub suppression; `false` to disable and tear down.
+   * @throws When enabling without login, on unsupported BROWSER station login, or when usersub/Mercury init fails.
+   * @internal
+   * @see enableWxBetterTogether (CCPluginConfig init flag)
+   * @see ensureWxAppPostStationLogin
+   * @see teardownWxAppLocalState
+   */
+  private async setManageWebexCallingInWxcc(enabled: boolean): Promise<void> {
+    if (enabled && !this.$webex.internal.device?.userId) {
+      throw new Error('Cannot publish answer-calls-on-wxcc: user is not logged in');
+    }
+
+    if (enabled) {
+      this.assertWxAppStationLoginSupportedForEnable();
+    }
+
+    const previousEnabled = this.isWxBetterTogetherEnabled();
+
+    if (this.$config) {
+      this.$config.enableWxBetterTogether = enabled;
+    }
+
+    this.taskManager.applyEnableWxBetterTogether(enabled);
+
+    let publishedEnable = false;
+
+    try {
+      if (enabled) {
+        await this.ensureWxAppMercuryAndSubscribe();
+        await this.publishAnswerOnWebexCrossClientState(true);
+        publishedEnable = true;
+        this.taskManager.syncWxAppMuteFromCallDetailsForAllTasks();
+      } else {
+        await this.publishAnswerOnWebexCrossClientState(false);
+        this.wxAppTelephonyMercurySync.unsubscribe();
+        await this.releaseWxAppMercuryResources();
+      }
+    } catch (error) {
+      if (publishedEnable) {
+        await this.revertWxAppCrossClientPublish();
+      } else if (enabled) {
+        this.wxAppTelephonyMercurySync.unsubscribe();
+        await this.releaseWxAppMercuryResources();
+      }
+
+      if (this.$config) {
+        this.$config.enableWxBetterTogether = previousEnabled;
+      }
+      this.taskManager.applyEnableWxBetterTogether(previousEnabled);
+      throw error;
+    }
+  }
+
+  private getWxAppTelephonyTaskType(): 'Voice' | 'WebRTC' | 'unknown' {
+    const loginOption = this.getCurrentStationLoginOption();
+
+    if (loginOption === LoginOption.BROWSER) {
+      return 'WebRTC';
+    }
+
+    if (loginOption === LoginOption.EXTENSION || loginOption === LoginOption.AGENT_DN) {
+      return 'Voice';
+    }
+
+    return 'unknown';
+  }
+
+  private async ensureWxAppPostStationLogin(): Promise<void> {
+    const loginOption = this.getCurrentStationLoginOption();
+    const flagEnabled = this.isWxBetterTogetherEnabled();
+    const telephonyTaskType = this.getWxAppTelephonyTaskType();
+
+    if (loginOption === LoginOption.BROWSER) {
+      if (flagEnabled) {
+        logWxAppSessionReadiness({
+          enableWxBetterTogether: true,
+          loginOption,
+          wxAppHooksApplied: false,
+          usersubPublished: false,
+          mercurySubscribed: false,
+          telephonyTaskType,
+          skipReason: 'unsupported_browser_login',
+        });
+
+        this.metricsManager.trackEvent(
+          METRIC_EVENT_NAMES.WXAPP_SESSION_SKIPPED,
+          {
+            loginOption,
+            enableWxBetterTogether: true,
+            skipReason: 'unsupported_browser_login',
+          },
+          ['operational', 'behavioral']
+        );
+      }
+
+      return;
+    }
+
+    let publishedEnable = false;
+    let wxAppInitStage: 'mercury' | 'publish' = 'mercury';
+
+    try {
+      if (flagEnabled) {
+        this.metricsManager.timeEvent([
+          METRIC_EVENT_NAMES.WXAPP_SESSION_INIT_SUCCESS,
+          METRIC_EVENT_NAMES.WXAPP_SESSION_INIT_FAILED,
+        ]);
+
+        await this.ensureWxAppMercuryAndSubscribe();
+        wxAppInitStage = 'publish';
+        await this.publishAnswerOnWebexCrossClientState(true);
+        publishedEnable = true;
+        this.taskManager.syncWxAppMuteFromCallDetailsForAllTasks();
+
+        const mercurySubscribed = this.wxAppTelephonyMercurySync.isSubscribed();
+        const usersubPublished = this.webexCrossClientService.isAnswerCallsStateActive();
+
+        logWxAppSessionReadiness({
+          enableWxBetterTogether: true,
+          loginOption,
+          wxAppHooksApplied: true,
+          usersubPublished,
+          mercurySubscribed,
+          telephonyTaskType,
+        });
+
+        const sessionInitReady = mercurySubscribed && usersubPublished;
+
+        if (sessionInitReady) {
+          this.metricsManager.trackEvent(
+            METRIC_EVENT_NAMES.WXAPP_SESSION_INIT_SUCCESS,
+            {loginOption, enableWxBetterTogether: true},
+            ['operational', 'behavioral']
+          );
+        } else {
+          this.metricsManager.trackEvent(
+            METRIC_EVENT_NAMES.WXAPP_SESSION_INIT_FAILED,
+            {
+              loginOption,
+              enableWxBetterTogether: true,
+              skipReason: !usersubPublished ? 'usersub_not_published' : 'mercury_not_subscribed',
+            },
+            ['operational', 'behavioral']
+          );
+        }
+      } else {
+        await this.ensureWxAppDeviceRegistered();
+        await this.publishAnswerOnWebexCrossClientState(false, {force: true});
+        this.webexCrossClientService.teardown();
+        this.wxAppTelephonyMercurySync.unsubscribe();
+        await this.releaseWxAppMercuryResources();
+
+        logWxAppSessionReadiness({
+          enableWxBetterTogether: false,
+          loginOption,
+          wxAppHooksApplied: true,
+          usersubPublished: false,
+          mercurySubscribed: false,
+          telephonyTaskType,
+          skipReason: 'flag_disabled',
+        });
+
+        this.metricsManager.trackEvent(
+          METRIC_EVENT_NAMES.WXAPP_SESSION_SKIPPED,
+          {loginOption, enableWxBetterTogether: false, skipReason: 'flag_disabled'},
+          ['operational', 'behavioral']
+        );
+      }
+    } catch (error) {
+      LoggerProxy.error(`Failed to initialize wxApp post-station-login: ${error}`, {
+        module: CC_FILE,
+        method: METHODS.STATION_LOGIN,
+      });
+
+      if (flagEnabled) {
+        const sessionInitFailureReason =
+          wxAppInitStage === 'mercury' ? 'mercury_subscribe_failed' : 'publish_failed';
+
+        this.metricsManager.trackEvent(
+          METRIC_EVENT_NAMES.WXAPP_SESSION_INIT_FAILED,
+          {
+            loginOption,
+            enableWxBetterTogether: true,
+            skipReason: sessionInitFailureReason,
+            error: error instanceof Error ? error.toString() : String(error),
+          },
+          ['operational', 'behavioral']
+        );
+
+        logWxAppSessionReadiness({
+          enableWxBetterTogether: true,
+          loginOption,
+          wxAppHooksApplied: false,
+          usersubPublished:
+            publishedEnable && this.webexCrossClientService.isAnswerCallsStateActive(),
+          mercurySubscribed: this.wxAppTelephonyMercurySync.isSubscribed(),
+          telephonyTaskType,
+          skipReason: sessionInitFailureReason,
+        });
+
+        if (publishedEnable) {
+          await this.revertWxAppCrossClientPublish();
+        } else {
+          this.wxAppTelephonyMercurySync.unsubscribe();
+          await this.releaseWxAppMercuryResources();
+        }
+        this.resetEnableWxBetterTogetherConfig();
+      } else {
+        this.scheduleForcedFalsePublishRetry();
+      }
+    }
+  }
+
+  private clearWxAppFalsePublishRetryTimer(): void {
+    if (this.wxAppFalsePublishRetryTimer) {
+      clearTimeout(this.wxAppFalsePublishRetryTimer);
+      this.wxAppFalsePublishRetryTimer = undefined;
+    }
+  }
+
+  private scheduleForcedFalsePublishRetry(retryAttempt = 0): void {
+    this.scheduleFalsePublishRetry(retryAttempt, {requireDisabled: true});
+  }
+
+  /**
+   * Retries compensating false publish after rollback failure, regardless of enabled flag.
+   * @private
+   */
+  private scheduleCompensatingFalsePublishRetry(retryAttempt = 0): void {
+    this.scheduleFalsePublishRetry(retryAttempt);
+  }
+
+  private scheduleFalsePublishRetry(
+    retryAttempt = 0,
+    options: {requireDisabled?: boolean} = {}
+  ): void {
+    if (retryAttempt >= ContactCenter.WXAPP_FALSE_PUBLISH_MAX_RETRIES) {
+      return;
+    }
+
+    if (options?.requireDisabled && this.isWxBetterTogetherEnabled()) {
+      return;
+    }
+
+    this.clearWxAppFalsePublishRetryTimer();
+
+    this.wxAppFalsePublishRetryTimer = setTimeout(async () => {
+      this.wxAppFalsePublishRetryTimer = undefined;
+
+      if (options?.requireDisabled && this.isWxBetterTogetherEnabled()) {
+        return;
+      }
+
+      if (
+        !options?.requireDisabled &&
+        this.isWxBetterTogetherEnabled() &&
+        this.webexCrossClientService.isAnswerCallsStateActive()
+      ) {
+        return;
+      }
+
+      try {
+        await this.ensureWxAppDeviceRegistered();
+        await this.publishAnswerOnWebexCrossClientState(false, {force: true});
+        this.webexCrossClientService.teardown();
+        this.wxAppTelephonyMercurySync.unsubscribe();
+        await this.releaseWxAppMercuryResources();
+      } catch (retryError) {
+        LoggerProxy.error(
+          `Failed to retry forced answer-calls-on-wxcc false publish: ${retryError}`,
+          {
+            module: CC_FILE,
+            method: METHODS.SET_MANAGE_WEBEX_CALLING_IN_WXCC,
+          }
+        );
+        this.scheduleFalsePublishRetry(retryAttempt + 1, options);
+      }
+    }, ContactCenter.WXAPP_FALSE_PUBLISH_RETRY_DELAY_MS);
+  }
+
+  /**
+   * Best-effort rollback when usersub true was published but wxApp setup did not complete.
+   * @private
+   */
+  private async revertWxAppCrossClientPublish(): Promise<void> {
+    try {
+      await this.publishAnswerOnWebexCrossClientState(false, {force: true});
+    } catch (error) {
+      LoggerProxy.error(
+        `Failed to publish compensating answer-calls-on-wxcc false during wxApp rollback: ${error}`,
+        {
+          module: CC_FILE,
+          method: METHODS.SET_MANAGE_WEBEX_CALLING_IN_WXCC,
+        }
+      );
+      this.scheduleCompensatingFalsePublishRetry();
+    }
+
+    this.webexCrossClientService.teardown();
+    this.wxAppTelephonyMercurySync.unsubscribe();
+    await this.releaseWxAppMercuryResources();
+  }
+
+  private async ensureWxAppDeviceRegistered(): Promise<void> {
+    const device = this.$webex.internal.device;
+
+    if (device && !device.registered && device.register) {
+      await device.register();
+      this.wxAppDeviceRegisteredByCc = true;
+      LoggerProxy.log('WxApp: device registered for cross-client publish', {
+        module: CC_FILE,
+        method: METHODS.ENSURE_WXAPP_MERCURY_CONNECTED,
+      });
+    }
+  }
+
+  private async ensureWxAppMercuryConnected(): Promise<void> {
+    const mercury = this.$webex.internal.mercury;
+
+    await this.ensureWxAppDeviceRegistered();
+
+    if (mercury && !mercury.connected) {
+      await mercury.connect();
+      this.wxAppMercuryConnectedByCc = true;
+      LoggerProxy.log('WxApp mute sync: mercury connected', {
+        module: CC_FILE,
+        method: METHODS.ENSURE_WXAPP_MERCURY_CONNECTED,
+      });
+    }
+  }
+
+  /**
+   * Disconnects Mercury and unregisters the device when wxApp mute sync opened them.
+   * @private
+   */
+  private async releaseWxAppMercuryResources(): Promise<void> {
+    const mercury = this.$webex.internal.mercury;
+    const device = this.$webex.internal.device;
+
+    if (this.wxAppMercuryConnectedByCc && mercury?.connected) {
+      try {
+        await mercury.disconnect();
+        this.wxAppMercuryConnectedByCc = false;
+        LoggerProxy.log('WxApp mute sync: mercury disconnected', {
+          module: CC_FILE,
+          method: METHODS.ENSURE_WXAPP_MERCURY_CONNECTED,
+        });
+      } catch (error) {
+        LoggerProxy.error(`Failed to disconnect wxApp Mercury: ${error}`, {
+          module: CC_FILE,
+          method: METHODS.ENSURE_WXAPP_MERCURY_CONNECTED,
+        });
+      }
+    }
+
+    if (this.wxAppDeviceRegisteredByCc && device?.registered && device.unregister) {
+      try {
+        // @ts-ignore
+        await device.unregister();
+        this.wxAppDeviceRegisteredByCc = false;
+        LoggerProxy.log('WxApp mute sync: device unregistered', {
+          module: CC_FILE,
+          method: METHODS.ENSURE_WXAPP_MERCURY_CONNECTED,
+        });
+      } catch (error) {
+        LoggerProxy.error(`Failed to unregister wxApp device: ${error}`, {
+          module: CC_FILE,
+          method: METHODS.ENSURE_WXAPP_MERCURY_CONNECTED,
+        });
+      }
+    } else if (this.wxAppDeviceRegisteredByCc) {
+      this.wxAppDeviceRegisteredByCc = false;
+    }
+  }
+
+  /**
+   * Clears wxApp runtime state and feature-owned resources. Publish failures are logged;
+   * optional rethrow for deregister when callers need to surface usersub errors.
+   * @private
+   */
+  private async teardownWxAppLocalState(options?: {
+    rethrowPublishError?: boolean;
+    clearInitFlag?: boolean;
+  }): Promise<{publishError?: unknown}> {
+    this.clearWxAppFalsePublishRetryTimer();
+    let publishError: unknown;
+
+    try {
+      const shouldForceFalsePublish =
+        this.isWxBetterTogetherEnabled() || this.webexCrossClientService.isAnswerCallsStateActive();
+
+      await this.publishAnswerOnWebexCrossClientState(false, {
+        force: shouldForceFalsePublish,
+      });
+    } catch (error) {
+      publishError = error;
+      LoggerProxy.error(
+        `Failed to publish answer-calls-on-wxcc false during wxApp teardown: ${error}`,
+        {
+          module: CC_FILE,
+          method: METHODS.SET_MANAGE_WEBEX_CALLING_IN_WXCC,
+        }
+      );
+    }
+
+    this.webexCrossClientService.teardown();
+    this.wxAppTelephonyMercurySync.unsubscribe();
+    await this.releaseWxAppMercuryResources();
+
+    if (options?.clearInitFlag) {
+      this.resetEnableWxBetterTogetherConfig();
+    }
+
+    if (publishError) {
+      this.scheduleCompensatingFalsePublishRetry();
+    }
+
+    if (options?.rethrowPublishError && publishError) {
+      throw publishError;
+    }
+
+    return {publishError: publishError ?? undefined};
+  }
+
+  private async ensureWxAppMercuryAndSubscribe(): Promise<void> {
+    if (!this.isWxBetterTogetherEnabled()) {
+      return;
+    }
+
+    if (this.getCurrentStationLoginOption() === LoginOption.BROWSER) {
+      return;
+    }
+
+    const agentId = this.agentConfig?.agentId;
+    if (!agentId) {
+      LoggerProxy.error('Cannot subscribe wxApp mute sync: agentId unavailable', {
+        module: CC_FILE,
+        method: METHODS.SYNC_WXAPP_MUTE_FROM_MERCURY,
+      });
+
+      this.metricsManager.trackEvent(
+        METRIC_EVENT_NAMES.WXAPP_MERCURY_SUBSCRIBE_FAILED,
+        {error: 'agentId unavailable'},
+        ['operational', 'behavioral']
+      );
+
+      return;
+    }
+
+    try {
+      await this.ensureWxAppMercuryConnected();
+      this.wxAppTelephonyMercurySync.subscribe(agentId, (callId, muted) => {
+        this.taskManager.applyWxAppMuteStateFromSync(callId, muted);
+      });
+    } catch (error) {
+      LoggerProxy.error(`Failed to ensure wxApp Mercury mute sync: ${error}`, {
+        module: CC_FILE,
+        method: METHODS.SYNC_WXAPP_MUTE_FROM_MERCURY,
+      });
+      this.metricsManager.trackEvent(
+        METRIC_EVENT_NAMES.WXAPP_MERCURY_SUBSCRIBE_FAILED,
+        {error: error instanceof Error ? error.toString() : String(error)},
+        ['operational', 'behavioral']
+      );
+      this.wxAppTelephonyMercurySync.unsubscribe();
+      await this.releaseWxAppMercuryResources();
+      throw error;
+    }
+  }
+
+  private async publishAnswerOnWebexCrossClientState(
+    enable: boolean,
+    options?: {force?: boolean}
+  ): Promise<void> {
+    if (enable && !this.isWxBetterTogetherEnabled()) {
+      return;
+    }
+
+    if (!enable && !options?.force && !this.webexCrossClientService.isAnswerCallsStateActive()) {
+      return;
+    }
+
+    const userId = this.$webex.internal.device?.userId;
+    if (!userId) {
+      if (enable && this.isWxBetterTogetherEnabled()) {
+        this.metricsManager.trackEvent(
+          METRIC_EVENT_NAMES.WXAPP_USERSUB_PUBLISH_FAILED,
+          {
+            enableWxBetterTogether: true,
+            skipReason: 'user_id_unavailable',
+            error: 'User ID is unavailable for cross-client publish',
+          },
+          ['operational', 'behavioral']
+        );
+      }
+
+      return;
+    }
+
+    await this.webexCrossClientService.setManageWebexCallingInWxcc(enable, {
+      userId,
+      trackPublishMetrics: true,
+    });
+
+    if (enable) {
+      this.clearWxAppFalsePublishRetryTimer();
+    }
+  }
+
   /**
    * Initializes event listeners for the Contact Center service
    * Sets up handlers for connection state changes and other core events
@@ -1277,13 +2051,13 @@ export default class ContactCenter extends WebexPlugin implements IContactCenter
   private async handleConnectionLost(msg: ConnectionLostDetails): Promise<void> {
     if (msg.isConnectionLost) {
       // TODO: Emit an event saying connection is lost
-      LoggerProxy.info('event=handleConnectionLost | Connection lost', {
+      LoggerProxy.log('event=handleConnectionLost | Connection lost', {
         module: CC_FILE,
         method: METHODS.HANDLE_CONNECTION_LOST,
       });
     } else if (msg.isSocketReconnected) {
       // TODO: Emit an event saying connection is re-estabilished
-      LoggerProxy.info(
+      LoggerProxy.log(
         'event=handleConnectionReconnect | Connection reconnected attempting to request silent relogin',
         {module: CC_FILE, method: METHODS.HANDLE_CONNECTION_LOST}
       );
@@ -1298,7 +2072,7 @@ export default class ContactCenter extends WebexPlugin implements IContactCenter
    * @private
    */
   private async silentRelogin(): Promise<void> {
-    LoggerProxy.info('Starting silent relogin process', {
+    LoggerProxy.log('Starting silent relogin process', {
       module: CC_FILE,
       method: METHODS.SILENT_RELOGIN,
     });
@@ -1320,7 +2094,7 @@ export default class ContactCenter extends WebexPlugin implements IContactCenter
       await this.handleDeviceType(deviceType as LoginOption, dn);
 
       if (lastStateChangeReason === 'agent-wss-disconnect') {
-        LoggerProxy.info(
+        LoggerProxy.log(
           'event=requestAutoStateChange | Requesting state change to available on socket reconnect',
           {module: CC_FILE, method: METHODS.SILENT_RELOGIN}
         );
@@ -1349,8 +2123,8 @@ export default class ContactCenter extends WebexPlugin implements IContactCenter
       }
       this.agentConfig.lastStateAuxCodeId = auxCodeId;
       this.agentConfig.isAgentLoggedIn = true;
-      // TODO: https://jira-eng-gpk2.cisco.com/jira/browse/SPARK-626777 Implement the de-register method and close the listener there
-      this.services.webSocketManager.on('message', this.handleWebsocketMessage);
+
+      await this.ensureWxAppPostStationLogin();
 
       LoggerProxy.log(
         `Silent relogin process completed successfully with login Option: ${reLoginResponse.data.deviceType} teamId: ${reLoginResponse.data.teamId}`,
@@ -1391,6 +2165,16 @@ export default class ContactCenter extends WebexPlugin implements IContactCenter
     this.agentConfig.deviceType = deviceType;
     switch (deviceType) {
       case LoginOption.BROWSER:
+        if (this.isWebRTCRegistrationDisabled()) {
+          LoggerProxy.info(
+            'Skipping web calling line registration because disableWebRTCRegistration is enabled',
+            {
+              module: CC_FILE,
+              method: METHODS.HANDLE_DEVICE_TYPE,
+            }
+          );
+          break;
+        }
         try {
           await this.webCallingService.registerWebCallingLine();
         } catch (error) {
@@ -1656,6 +2440,166 @@ export default class ContactCenter extends WebexPlugin implements IContactCenter
     }
   }
 
+  /**
+   * Skips a campaign preview contact, requesting the next contact from the campaign.
+   *
+   * When a campaign manager reserves a contact for an agent, the agent receives an
+   * `AgentOfferCampaignReservation` event. Instead of accepting, the agent can skip the
+   * preview contact to move to the next contact in the campaign.
+   *
+   * @param {PreviewContactPayload} payload - The preview contact payload containing interactionId and campaignId (campaign name, not UUID).
+   * @returns {Promise<TaskResponse>} Promise resolving with agent contact on success.
+   * @throws {Error} If the operation fails (network error, etc.)
+   *
+   * @example
+   * ```typescript
+   * webex.cc.on('task:campaignPreviewReservation', async (task) => {
+   *   const { interactionId } = task.data;
+   *   const campaignId = task.data.interaction.callProcessingDetails.campaignId;
+   *
+   *   const result = await webex.cc.skipPreviewContact({ interactionId, campaignId });
+   * });
+   * ```
+   */
+  public async skipPreviewContact(payload: PreviewContactPayload): Promise<TaskResponse> {
+    const task = this.taskManager.getTask(payload.interactionId);
+    if (task?.data?.interaction?.callProcessingDetails?.campaignPreviewSkipDisabled === 'true') {
+      LoggerProxy.warn('Skip action is disabled for this campaign preview contact', {
+        module: CC_FILE,
+        method: METHODS.SKIP_PREVIEW_CONTACT,
+        interactionId: payload.interactionId,
+      });
+      throw new Error('Skip action is disabled for this campaign preview contact');
+    }
+
+    LoggerProxy.info('Skipping campaign preview contact', {
+      module: CC_FILE,
+      method: METHODS.SKIP_PREVIEW_CONTACT,
+    });
+    try {
+      this.metricsManager.timeEvent([
+        METRIC_EVENT_NAMES.CAMPAIGN_PREVIEW_SKIP_SUCCESS,
+        METRIC_EVENT_NAMES.CAMPAIGN_PREVIEW_SKIP_FAILED,
+      ]);
+
+      const result = await this.services.dialer.skipPreviewContact({data: payload});
+
+      this.metricsManager.trackEvent(
+        METRIC_EVENT_NAMES.CAMPAIGN_PREVIEW_SKIP_SUCCESS,
+        {
+          ...MetricsManager.getCommonTrackingFieldForAQMResponse(result),
+          interactionId: payload.interactionId,
+          campaignId: payload.campaignId,
+        },
+        ['behavioral', 'business', 'operational']
+      );
+
+      LoggerProxy.log('Campaign preview contact skipped successfully', {
+        module: CC_FILE,
+        method: METHODS.SKIP_PREVIEW_CONTACT,
+        trackingId: result.trackingId,
+        interactionId: payload.interactionId,
+      });
+
+      return result;
+    } catch (error) {
+      const failure = error.details as Failure;
+      this.metricsManager.trackEvent(
+        METRIC_EVENT_NAMES.CAMPAIGN_PREVIEW_SKIP_FAILED,
+        {
+          ...MetricsManager.getCommonTrackingFieldForAQMResponseFailed(failure),
+          interactionId: payload.interactionId,
+          campaignId: payload.campaignId,
+        },
+        ['behavioral', 'business', 'operational']
+      );
+      const {error: detailedError} = getErrorDetails(error, METHODS.SKIP_PREVIEW_CONTACT, CC_FILE);
+      throw detailedError;
+    }
+  }
+
+  /**
+   * Removes a campaign preview contact from the campaign list entirely.
+   *
+   * When a campaign manager reserves a contact for an agent, the agent receives an
+   * `AgentOfferCampaignReservation` event. Instead of accepting or skipping, the agent can
+   * remove the preview contact to permanently take it out of the campaign contact list.
+   *
+   * @param {PreviewContactPayload} payload - The preview contact payload containing interactionId and campaignId (campaign name, not UUID).
+   * @returns {Promise<TaskResponse>} Promise resolving with agent contact on success.
+   * @throws {Error} If the operation fails (network error, etc.)
+   *
+   * @example
+   * ```typescript
+   * webex.cc.on('task:campaignPreviewReservation', async (task) => {
+   *   const { interactionId } = task.data;
+   *   const campaignId = task.data.interaction.callProcessingDetails.campaignId;
+   *
+   *   const result = await webex.cc.removePreviewContact({ interactionId, campaignId });
+   * });
+   * ```
+   */
+  public async removePreviewContact(payload: PreviewContactPayload): Promise<TaskResponse> {
+    const task = this.taskManager.getTask(payload.interactionId);
+    if (task?.data?.interaction?.callProcessingDetails?.campaignPreviewRemoveDisabled === 'true') {
+      LoggerProxy.warn('Remove action is disabled for this campaign preview contact', {
+        module: CC_FILE,
+        method: METHODS.REMOVE_PREVIEW_CONTACT,
+        interactionId: payload.interactionId,
+      });
+      throw new Error('Remove action is disabled for this campaign preview contact');
+    }
+
+    LoggerProxy.info('Removing campaign preview contact', {
+      module: CC_FILE,
+      method: METHODS.REMOVE_PREVIEW_CONTACT,
+    });
+    try {
+      this.metricsManager.timeEvent([
+        METRIC_EVENT_NAMES.CAMPAIGN_PREVIEW_REMOVE_SUCCESS,
+        METRIC_EVENT_NAMES.CAMPAIGN_PREVIEW_REMOVE_FAILED,
+      ]);
+
+      const result = await this.services.dialer.removePreviewContact({data: payload});
+
+      this.metricsManager.trackEvent(
+        METRIC_EVENT_NAMES.CAMPAIGN_PREVIEW_REMOVE_SUCCESS,
+        {
+          ...MetricsManager.getCommonTrackingFieldForAQMResponse(result),
+          interactionId: payload.interactionId,
+          campaignId: payload.campaignId,
+        },
+        ['behavioral', 'business', 'operational']
+      );
+
+      LoggerProxy.log('Campaign preview contact removed successfully', {
+        module: CC_FILE,
+        method: METHODS.REMOVE_PREVIEW_CONTACT,
+        trackingId: result.trackingId,
+        interactionId: payload.interactionId,
+      });
+
+      return result;
+    } catch (error) {
+      const failure = error.details as Failure;
+      this.metricsManager.trackEvent(
+        METRIC_EVENT_NAMES.CAMPAIGN_PREVIEW_REMOVE_FAILED,
+        {
+          ...MetricsManager.getCommonTrackingFieldForAQMResponseFailed(failure),
+          interactionId: payload.interactionId,
+          campaignId: payload.campaignId,
+        },
+        ['behavioral', 'business', 'operational']
+      );
+      const {error: detailedError} = getErrorDetails(
+        error,
+        METHODS.REMOVE_PREVIEW_CONTACT,
+        CC_FILE
+      );
+      throw detailedError;
+    }
+  }
+
   /**
    * Fetches outdial ANI (Automatic Number Identification) entries for an outdial ANI ID.
    *
@@ -1900,8 +2844,8 @@ export default class ContactCenter extends WebexPlugin implements IContactCenter
   }
 
   /**
-   * Returns paginated entry points for the organization.
-   * Thin wrapper around internal EntryPoint instance.
+   * Returns paginated entry points using the EntryPoint service defaults.
+   * Existing request parameters can override those defaults.
    * @public
    */
   public async getEntryPoints(
@@ -1911,8 +2855,8 @@ export default class ContactCenter extends WebexPlugin implements IContactCenter
   }
 
   /**
-   * Returns paginated contact service queues for the organization.
-   * Thin wrapper around internal Queue instance.
+   * Returns paginated contact service queues using the Queue service defaults.
+   * Existing request parameters can override those defaults.
    * @public
    */
   public async getQueues(