@webex/contact-center 3.12.0-task-refactor.11 → 3.12.0-task-refactor.12

package/dist/cc.js

@@ -85,6 +85,7 @@ function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e
  *   - `task:established` - Task/call has been connected
  *   - `task:ended` - Task/call has ended
  *   - `task:error` - An error occurred during task handling
+ *   - `task:campaignPreviewReservation` - Campaign preview contact offered to agent
  *
  * @public
  *
@@ -312,7 +313,6 @@ class ContactCenter extends _webexCore.WebexPlugin {
         webex: this.$webex,
         connectionConfig: this.getConnectionConfig()
       });
-      this.services.webSocketManager.on('message', this.handleWebsocketMessage);
       this.webCallingService = new _WebCallingService.default(this.$webex);
       this.apiAIAssistant = new _ApiAiAssistant.ApiAIAssistant(this.$webex);
       this.metricsManager = _MetricsManager.default.getInstance({
@@ -370,6 +370,19 @@ class ContactCenter extends _webexCore.WebexPlugin {
     this.trigger(_types4.TASK_EVENTS.TASK_MERGED, task);
   };
 
+  /**
+   * Handles campaign preview reservation events when a contact is offered to the agent
+   * @private
+   * @param {ITask} task The campaign reservation task
+   */
+  handleCampaignPreviewReservation = task => {
+    // @ts-ignore
+    this.trigger(_types4.TASK_EVENTS.TASK_CAMPAIGN_PREVIEW_RESERVATION, task);
+  };
+  handleRTDWebsocketMessage = event => {
+    this.taskManager.handleRealtimeWebsocketEvent(event);
+  };
+
   /**
    * Sets up event listeners for incoming tasks and task hydration
    * Subscribes to task events from the task manager
@@ -380,6 +393,7 @@ class ContactCenter extends _webexCore.WebexPlugin {
     this.taskManager.on(_types4.TASK_EVENTS.TASK_HYDRATE, this.handleTaskHydrate);
     this.taskManager.on(_types4.TASK_EVENTS.TASK_MULTI_LOGIN_HYDRATE, this.handleTaskMultiLoginHydrate);
     this.taskManager.on(_types4.TASK_EVENTS.TASK_MERGED, this.handleTaskMerged);
+    this.taskManager.on(_types4.TASK_EVENTS.TASK_CAMPAIGN_PREVIEW_RESERVATION, this.handleCampaignPreviewReservation);
   }
 
   /**
@@ -419,13 +433,14 @@ class ContactCenter extends _webexCore.WebexPlugin {
    * ```
    */
   async register() {
-    _loggerProxy.default.info('Starting CC SDK registration', {
+    _loggerProxy.default.log('Starting CC SDK registration', {
       module: _constants.CC_FILE,
       method: _constants.METHODS.REGISTER
     });
     try {
       this.metricsManager.timeEvent([_constants4.METRIC_EVENT_NAMES.WEBSOCKET_REGISTER_SUCCESS, _constants4.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'
       resp.dn = resp.defaultDn;
@@ -489,6 +504,7 @@ class ContactCenter extends _webexCore.WebexPlugin {
       this.taskManager.off(_types4.TASK_EVENTS.TASK_INCOMING, this.handleIncomingTask);
       this.taskManager.off(_types4.TASK_EVENTS.TASK_HYDRATE, this.handleTaskHydrate);
       this.taskManager.off(_types4.TASK_EVENTS.TASK_MULTI_LOGIN_HYDRATE, this.handleTaskMultiLoginHydrate);
+      this.taskManager.off(_types4.TASK_EVENTS.TASK_CAMPAIGN_PREVIEW_RESERVATION, this.handleCampaignPreviewReservation);
       this.taskManager.unregisterIncomingCallEvent();
       this.services.webSocketManager.off('message', this.handleWebsocketMessage);
       this.services.rtdWebSocketManager.off('message', this.handleRTDWebsocketMessage);
@@ -512,6 +528,9 @@ class ContactCenter extends _webexCore.WebexPlugin {
       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');
+      }
 
       // Clear any cached agent configuration
       this.agentConfig = null;
@@ -613,85 +632,89 @@ class ContactCenter extends _webexCore.WebexPlugin {
    * @private
    */
   async connectWebsocket() {
-    _loggerProxy.default.info('Connecting to websocket', {
+    _loggerProxy.default.log('Connecting to websocket', {
       module: _constants.CC_FILE,
       method: _constants.METHODS.CONNECT_WEBSOCKET
     });
     try {
-      return this.services.webSocketManager.initWebSocket({
+      const data = await this.services.webSocketManager.initWebSocket({
         body: this.getConnectionConfig(),
         resource: _constants3.SUBSCRIBE_API
-      }).then(async data => {
-        const agentId = data.agentId;
-        const orgId = this.$webex.credentials.getOrgId();
-        this.agentConfig = await this.services.config.getAgentConfig(orgId, agentId);
-        _loggerProxy.default.log(`Agent config is fetched successfully`, {
+      });
+      const agentId = data.agentId;
+      const orgId = this.$webex.credentials.getOrgId();
+      this.agentConfig = await this.services.config.getAgentConfig(orgId, agentId);
+      _loggerProxy.default.log(`Agent config is fetched successfully`, {
+        module: _constants.CC_FILE,
+        method: _constants.METHODS.CONNECT_WEBSOCKET
+      });
+      const configFlags = {
+        isEndTaskEnabled: this.agentConfig.isEndTaskEnabled,
+        isEndConsultEnabled: this.agentConfig.isEndConsultEnabled,
+        webRtcEnabled: this.agentConfig.webRtcEnabled,
+        autoWrapup: this.agentConfig.wrapUpData?.wrapUpProps?.autoWrapup ?? false,
+        aiFeature: this.agentConfig.aiFeature
+      };
+      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);
+
+      /**
+       * 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.default.info('Connecting to RTD websocket', {
           module: _constants.CC_FILE,
           method: _constants.METHODS.CONNECT_WEBSOCKET
         });
-        const configFlags = {
-          isEndTaskEnabled: this.agentConfig.isEndTaskEnabled,
-          isEndConsultEnabled: this.agentConfig.isEndConsultEnabled,
-          webRtcEnabled: this.agentConfig.webRtcEnabled,
-          autoWrapup: this.agentConfig.wrapUpData?.wrapUpProps?.autoWrapup ?? false,
-          aiFeature: this.agentConfig.aiFeature
-        };
-        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);
-        /**
-         * 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.default.info('Connecting to RTD websocket', {
+        this.services.rtdWebSocketManager.initWebSocket({
+          body: this.getConnectionConfig(),
+          resource: _constants3.RTD_SUBSCRIBE_API
+        }).then(() => {
+          _loggerProxy.default.log('RTD websocket connected successfully', {
             module: _constants.CC_FILE,
             method: _constants.METHODS.CONNECT_WEBSOCKET
           });
-          this.services.rtdWebSocketManager.initWebSocket({
-            body: this.getConnectionConfig(),
-            resource: _constants3.RTD_SUBSCRIBE_API
-          }).then(() => {
-            _loggerProxy.default.log('RTD websocket connected successfully', {
-              module: _constants.CC_FILE,
-              method: _constants.METHODS.CONNECT_WEBSOCKET
-            });
-            this.services.rtdWebSocketManager.on('message', this.handleRTDWebsocketMessage);
-          }).catch(error => {
-            _loggerProxy.default.error(`Error connecting to RTD websocket ${error}`, {
-              module: _constants.CC_FILE,
-              method: _constants.METHODS.CONNECT_WEBSOCKET
-            });
+          this.services.rtdWebSocketManager.on('message', this.handleRTDWebsocketMessage);
+        }).catch(error => {
+          _loggerProxy.default.error(`Error connecting to RTD websocket ${error}`, {
+            module: _constants.CC_FILE,
+            method: _constants.METHODS.CONNECT_WEBSOCKET
           });
-        }
-        if (this.agentConfig.webRtcEnabled && this.agentConfig.loginVoiceOptions.includes(_types.LoginOption.BROWSER) && !this.isWebRTCRegistrationDisabled()) {
-          this.$webex.internal.mercury.connect().then(() => {
-            _loggerProxy.default.log('Authentication: webex.internal.mercury.connect successful', {
-              module: _constants.CC_FILE,
-              method: _constants.METHODS.CONNECT_WEBSOCKET
-            });
-          }).catch(error => {
-            _loggerProxy.default.error(`Error occurred during mercury.connect() ${error}`, {
-              module: _constants.CC_FILE,
-              method: _constants.METHODS.CONNECT_WEBSOCKET
-            });
+        });
+      }
+      if (this.agentConfig.webRtcEnabled && this.agentConfig.loginVoiceOptions.includes(_types.LoginOption.BROWSER) && !this.isWebRTCRegistrationDisabled()) {
+        try {
+          await this.$webex.internal.mercury.connect();
+          _loggerProxy.default.log('Authentication: webex.internal.mercury.connect successful', {
+            module: _constants.CC_FILE,
+            method: _constants.METHODS.CONNECT_WEBSOCKET
           });
-        } else if (this.isWebRTCRegistrationDisabled()) {
-          _loggerProxy.default.info('Skipping Mobius registration because disableWebRTCRegistration is enabled', {
+        } catch (error) {
+          _loggerProxy.default.error(`Error occurred during mercury.connect() ${error}`, {
             module: _constants.CC_FILE,
             method: _constants.METHODS.CONNECT_WEBSOCKET
           });
         }
-        if (this.$config && this.$config.allowAutomatedRelogin) {
-          await this.silentRelogin();
-        }
-        return this.agentConfig;
-      }).catch(error => {
-        throw error;
-      });
+      } else if (this.isWebRTCRegistrationDisabled()) {
+        _loggerProxy.default.info('Skipping Mobius registration because disableWebRTCRegistration is enabled', {
+          module: _constants.CC_FILE,
+          method: _constants.METHODS.CONNECT_WEBSOCKET
+        });
+      }
+      if (this.$config && this.$config.allowAutomatedRelogin) {
+        await this.silentRelogin();
+      } else {
+        _loggerProxy.default.log('Skipping silent relogin: allowAutomatedRelogin is disabled', {
+          module: _constants.CC_FILE,
+          method: _constants.METHODS.CONNECT_WEBSOCKET
+        });
+      }
+      return this.agentConfig;
     } catch (error) {
       _loggerProxy.default.error(`Error during register: ${error}`, {
         module: _constants.CC_FILE,
@@ -730,21 +753,27 @@ class ContactCenter extends _webexCore.WebexPlugin {
    * ```
    */
   async stationLogin(data) {
-    _loggerProxy.default.info('Starting agent station login', {
+    const loggerContext = {
       module: _constants.CC_FILE,
       method: _constants.METHODS.STATION_LOGIN
-    });
+    };
     try {
+      _loggerProxy.default.log(`Starting agent station login | loginOption: ${data?.loginOption} teamId: ${data?.teamId}`, loggerContext);
       this.metricsManager.timeEvent([_constants4.METRIC_EVENT_NAMES.STATION_LOGIN_SUCCESS, _constants4.METRIC_EVENT_NAMES.STATION_LOGIN_FAILED]);
-      if (data.loginOption === _types.LoginOption.AGENT_DN && !(0, _Utils.isValidDialNumber)(data.dialNumber)) {
-        const error = new Error('INVALID_DIAL_NUMBER');
-        // @ts-ignore - adding custom key to the error object
-        error.details = {
-          data: {
-            reason: 'INVALID_DIAL_NUMBER'
-          }
-        };
-        throw error;
+      const dialPlanEntries = this.agentConfig?.dialPlan?.dialPlanEntity ?? [];
+      if (data.loginOption === _types.LoginOption.AGENT_DN) {
+        _loggerProxy.default.log(`Validating dial number | dialPlanEnabled: ${!!this.agentConfig?.dialPlan} | dialPlanEntryCount: ${dialPlanEntries.length}`, loggerContext);
+        if (!(0, _Utils.isValidDialNumber)(data.dialNumber, dialPlanEntries)) {
+          _loggerProxy.default.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'
+            }
+          };
+          throw error;
+        }
       }
       const loginResponse = await this.services.agent.stationLogin({
         data: {
@@ -1089,9 +1118,6 @@ class ContactCenter extends _webexCore.WebexPlugin {
         break;
     }
   };
-  handleRTDWebsocketMessage = event => {
-    this.taskManager.handleRealtimeWebsocketEvent(event);
-  };
 
   /**
    * Checks whether Mobius/WebRTC registration should be skipped by config
@@ -1143,13 +1169,13 @@ class ContactCenter extends _webexCore.WebexPlugin {
   async handleConnectionLost(msg) {
     if (msg.isConnectionLost) {
       // TODO: Emit an event saying connection is lost
-      _loggerProxy.default.info('event=handleConnectionLost | Connection lost', {
+      _loggerProxy.default.log('event=handleConnectionLost | Connection lost', {
         module: _constants.CC_FILE,
         method: _constants.METHODS.HANDLE_CONNECTION_LOST
       });
     } else if (msg.isSocketReconnected) {
       // TODO: Emit an event saying connection is re-estabilished
-      _loggerProxy.default.info('event=handleConnectionReconnect | Connection reconnected attempting to request silent relogin', {
+      _loggerProxy.default.log('event=handleConnectionReconnect | Connection reconnected attempting to request silent relogin', {
         module: _constants.CC_FILE,
         method: _constants.METHODS.HANDLE_CONNECTION_LOST
       });
@@ -1164,7 +1190,7 @@ class ContactCenter extends _webexCore.WebexPlugin {
    * @private
    */
   async silentRelogin() {
-    _loggerProxy.default.info('Starting silent relogin process', {
+    _loggerProxy.default.log('Starting silent relogin process', {
       module: _constants.CC_FILE,
       method: _constants.METHODS.SILENT_RELOGIN
     });
@@ -1186,7 +1212,7 @@ class ContactCenter extends _webexCore.WebexPlugin {
       this.agentConfig.currentTeamId = reLoginResponse.data.teamId;
       await this.handleDeviceType(deviceType, dn);
       if (lastStateChangeReason === 'agent-wss-disconnect') {
-        _loggerProxy.default.info('event=requestAutoStateChange | Requesting state change to available on socket reconnect', {
+        _loggerProxy.default.log('event=requestAutoStateChange | Requesting state change to available on socket reconnect', {
           module: _constants.CC_FILE,
           method: _constants.METHODS.SILENT_RELOGIN
         });
@@ -1210,8 +1236,6 @@ class ContactCenter extends _webexCore.WebexPlugin {
       }
       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);
       _loggerProxy.default.log(`Silent relogin process completed successfully with login Option: ${reLoginResponse.data.deviceType} teamId: ${reLoginResponse.data.teamId}`, {
         module: _constants.CC_FILE,
         method: _constants.METHODS.SILENT_RELOGIN,
@@ -1434,6 +1458,196 @@ class ContactCenter extends _webexCore.WebexPlugin {
     }
   }
 
+  /**
+   * Accepts a campaign preview contact, initiating the outbound call.
+   *
+   * When a campaign manager reserves a contact for an agent, the agent receives an
+   * `AgentOfferCampaignReservation` event. The agent can then accept the preview contact
+   * to initiate the outbound call.
+   *
+   * @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, customer unavailable, etc.)
+   *
+   * @example
+   * ```typescript
+   * webex.cc.on('task:campaignPreviewReservation', async (task) => {
+   *   const { interactionId } = task.data;
+   *   // campaignId is the campaign name (e.g. "MyCampaign"), not a UUID
+   *   const campaignId = task.data.interaction.callProcessingDetails.campaignId;
+   *
+   *   const result = await webex.cc.acceptPreviewContact({ interactionId, campaignId });
+   * });
+   * ```
+   */
+  async acceptPreviewContact(payload) {
+    _loggerProxy.default.info('Accepting campaign preview contact', {
+      module: _constants.CC_FILE,
+      method: _constants.METHODS.ACCEPT_PREVIEW_CONTACT
+    });
+    try {
+      this.metricsManager.timeEvent([_constants4.METRIC_EVENT_NAMES.CAMPAIGN_PREVIEW_ACCEPT_SUCCESS, _constants4.METRIC_EVENT_NAMES.CAMPAIGN_PREVIEW_ACCEPT_FAILED]);
+      const result = await this.services.dialer.acceptPreviewContact({
+        data: payload
+      });
+      this.metricsManager.trackEvent(_constants4.METRIC_EVENT_NAMES.CAMPAIGN_PREVIEW_ACCEPT_SUCCESS, {
+        ..._MetricsManager.default.getCommonTrackingFieldForAQMResponse(result),
+        interactionId: payload.interactionId,
+        campaignId: payload.campaignId
+      }, ['behavioral', 'business', 'operational']);
+      _loggerProxy.default.log('Campaign preview contact accepted successfully', {
+        module: _constants.CC_FILE,
+        method: _constants.METHODS.ACCEPT_PREVIEW_CONTACT,
+        trackingId: result.trackingId,
+        interactionId: payload.interactionId
+      });
+      return result;
+    } catch (error) {
+      const failure = error.details;
+      this.metricsManager.trackEvent(_constants4.METRIC_EVENT_NAMES.CAMPAIGN_PREVIEW_ACCEPT_FAILED, {
+        ..._MetricsManager.default.getCommonTrackingFieldForAQMResponseFailed(failure),
+        interactionId: payload.interactionId,
+        campaignId: payload.campaignId
+      }, ['behavioral', 'business', 'operational']);
+      const {
+        error: detailedError
+      } = (0, _Utils.getErrorDetails)(error, _constants.METHODS.ACCEPT_PREVIEW_CONTACT, _constants.CC_FILE);
+      throw detailedError;
+    }
+  }
+
+  /**
+   * 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 });
+   * });
+   * ```
+   */
+  async skipPreviewContact(payload) {
+    const task = this.taskManager.getTask(payload.interactionId);
+    if (task?.data?.interaction?.callProcessingDetails?.campaignPreviewSkipDisabled === 'true') {
+      _loggerProxy.default.warn('Skip action is disabled for this campaign preview contact', {
+        module: _constants.CC_FILE,
+        method: _constants.METHODS.SKIP_PREVIEW_CONTACT,
+        interactionId: payload.interactionId
+      });
+      throw new Error('Skip action is disabled for this campaign preview contact');
+    }
+    _loggerProxy.default.info('Skipping campaign preview contact', {
+      module: _constants.CC_FILE,
+      method: _constants.METHODS.SKIP_PREVIEW_CONTACT
+    });
+    try {
+      this.metricsManager.timeEvent([_constants4.METRIC_EVENT_NAMES.CAMPAIGN_PREVIEW_SKIP_SUCCESS, _constants4.METRIC_EVENT_NAMES.CAMPAIGN_PREVIEW_SKIP_FAILED]);
+      const result = await this.services.dialer.skipPreviewContact({
+        data: payload
+      });
+      this.metricsManager.trackEvent(_constants4.METRIC_EVENT_NAMES.CAMPAIGN_PREVIEW_SKIP_SUCCESS, {
+        ..._MetricsManager.default.getCommonTrackingFieldForAQMResponse(result),
+        interactionId: payload.interactionId,
+        campaignId: payload.campaignId
+      }, ['behavioral', 'business', 'operational']);
+      _loggerProxy.default.log('Campaign preview contact skipped successfully', {
+        module: _constants.CC_FILE,
+        method: _constants.METHODS.SKIP_PREVIEW_CONTACT,
+        trackingId: result.trackingId,
+        interactionId: payload.interactionId
+      });
+      return result;
+    } catch (error) {
+      const failure = error.details;
+      this.metricsManager.trackEvent(_constants4.METRIC_EVENT_NAMES.CAMPAIGN_PREVIEW_SKIP_FAILED, {
+        ..._MetricsManager.default.getCommonTrackingFieldForAQMResponseFailed(failure),
+        interactionId: payload.interactionId,
+        campaignId: payload.campaignId
+      }, ['behavioral', 'business', 'operational']);
+      const {
+        error: detailedError
+      } = (0, _Utils.getErrorDetails)(error, _constants.METHODS.SKIP_PREVIEW_CONTACT, _constants.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 });
+   * });
+   * ```
+   */
+  async removePreviewContact(payload) {
+    const task = this.taskManager.getTask(payload.interactionId);
+    if (task?.data?.interaction?.callProcessingDetails?.campaignPreviewRemoveDisabled === 'true') {
+      _loggerProxy.default.warn('Remove action is disabled for this campaign preview contact', {
+        module: _constants.CC_FILE,
+        method: _constants.METHODS.REMOVE_PREVIEW_CONTACT,
+        interactionId: payload.interactionId
+      });
+      throw new Error('Remove action is disabled for this campaign preview contact');
+    }
+    _loggerProxy.default.info('Removing campaign preview contact', {
+      module: _constants.CC_FILE,
+      method: _constants.METHODS.REMOVE_PREVIEW_CONTACT
+    });
+    try {
+      this.metricsManager.timeEvent([_constants4.METRIC_EVENT_NAMES.CAMPAIGN_PREVIEW_REMOVE_SUCCESS, _constants4.METRIC_EVENT_NAMES.CAMPAIGN_PREVIEW_REMOVE_FAILED]);
+      const result = await this.services.dialer.removePreviewContact({
+        data: payload
+      });
+      this.metricsManager.trackEvent(_constants4.METRIC_EVENT_NAMES.CAMPAIGN_PREVIEW_REMOVE_SUCCESS, {
+        ..._MetricsManager.default.getCommonTrackingFieldForAQMResponse(result),
+        interactionId: payload.interactionId,
+        campaignId: payload.campaignId
+      }, ['behavioral', 'business', 'operational']);
+      _loggerProxy.default.log('Campaign preview contact removed successfully', {
+        module: _constants.CC_FILE,
+        method: _constants.METHODS.REMOVE_PREVIEW_CONTACT,
+        trackingId: result.trackingId,
+        interactionId: payload.interactionId
+      });
+      return result;
+    } catch (error) {
+      const failure = error.details;
+      this.metricsManager.trackEvent(_constants4.METRIC_EVENT_NAMES.CAMPAIGN_PREVIEW_REMOVE_FAILED, {
+        ..._MetricsManager.default.getCommonTrackingFieldForAQMResponseFailed(failure),
+        interactionId: payload.interactionId,
+        campaignId: payload.campaignId
+      }, ['behavioral', 'business', 'operational']);
+      const {
+        error: detailedError
+      } = (0, _Utils.getErrorDetails)(error, _constants.METHODS.REMOVE_PREVIEW_CONTACT, _constants.CC_FILE);
+      throw detailedError;
+    }
+  }
+
   /**
    * Fetches outdial ANI (Automatic Number Identification) entries for an outdial ANI ID.
    *