@webex/contact-center 3.12.0-next.6 → 3.12.0-next.61

package/src/cc.ts

@@ -369,7 +369,6 @@ 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.apiAIAssistant = new ApiAIAssistant(this.$webex);
@@ -487,7 +486,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 +496,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'
@@ -731,7 +731,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,
     });
@@ -758,7 +758,7 @@ export default class ContactCenter extends WebexPlugin implements IContactCenter
       this.apiAIAssistant.setAIFeatureFlags(this.agentConfig.aiFeature);
 
       if (this.agentConfig.aiFeature?.realtimeTranscripts?.enable) {
-        LoggerProxy.info('Connecting to RTD websocket', {
+        LoggerProxy.log('Connecting to RTD websocket', {
           module: CC_FILE,
           method: METHODS.CONNECT_WEBSOCKET,
         });
@@ -803,6 +803,11 @@ export default class ContactCenter extends WebexPlugin implements IContactCenter
 
       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,26 +850,37 @@ 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 loginResponse = await this.services.agent.stationLogin({
@@ -1277,13 +1293,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 +1314,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 +1336,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 +1365,6 @@ 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);
 
       LoggerProxy.log(
         `Silent relogin process completed successfully with login Option: ${reLoginResponse.data.deviceType} teamId: ${reLoginResponse.data.teamId}`,
@@ -1656,6 +1670,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.
    *

package/src/constants.ts

@@ -50,6 +50,8 @@ export const METHODS = {
   HANDLE_TASK_HYDRATE: 'handleTaskHydrate',
   INCOMING_TASK_LISTENER: 'incomingTaskListener',
   ACCEPT_PREVIEW_CONTACT: 'acceptPreviewContact',
+  SKIP_PREVIEW_CONTACT: 'skipPreviewContact',
+  REMOVE_PREVIEW_CONTACT: 'removePreviewContact',
   GET_BASE_URL: 'getBaseUrl',
   SEND_EVENT: 'sendEvent',
   FETCH_HISTORIC_TRANSCRIPTS: 'fetchHistoricTranscripts',

package/src/metrics/behavioral-events.ts

@@ -449,6 +449,34 @@ const eventTaxonomyMap: Record<string, BehavioralEventTaxonomy> = {
     target: 'campaign_preview_accept',
     verb: 'fail',
   },
+
+  // Campaign Preview Skip API Events
+  [METRIC_EVENT_NAMES.CAMPAIGN_PREVIEW_SKIP_SUCCESS]: {
+    product,
+    agent: 'user',
+    target: 'campaign_preview_skip',
+    verb: 'complete',
+  },
+  [METRIC_EVENT_NAMES.CAMPAIGN_PREVIEW_SKIP_FAILED]: {
+    product,
+    agent: 'user',
+    target: 'campaign_preview_skip',
+    verb: 'fail',
+  },
+
+  // Campaign Preview Remove API Events
+  [METRIC_EVENT_NAMES.CAMPAIGN_PREVIEW_REMOVE_SUCCESS]: {
+    product,
+    agent: 'user',
+    target: 'campaign_preview_remove',
+    verb: 'complete',
+  },
+  [METRIC_EVENT_NAMES.CAMPAIGN_PREVIEW_REMOVE_FAILED]: {
+    product,
+    agent: 'user',
+    target: 'campaign_preview_remove',
+    verb: 'fail',
+  },
 };
 
 /**

package/src/metrics/constants.ts

@@ -163,6 +163,10 @@ export const METRIC_EVENT_NAMES = {
   // Campaign Preview API Events
   CAMPAIGN_PREVIEW_ACCEPT_SUCCESS: 'Campaign Preview Accept Success',
   CAMPAIGN_PREVIEW_ACCEPT_FAILED: 'Campaign Preview Accept Failed',
+  CAMPAIGN_PREVIEW_SKIP_SUCCESS: 'Campaign Preview Skip Success',
+  CAMPAIGN_PREVIEW_SKIP_FAILED: 'Campaign Preview Skip Failed',
+  CAMPAIGN_PREVIEW_REMOVE_SUCCESS: 'Campaign Preview Remove Success',
+  CAMPAIGN_PREVIEW_REMOVE_FAILED: 'Campaign Preview Remove Failed',
 
   // AI Assistant transcript events
   AI_ASSISTANT_SEND_EVENT_SUCCESS: 'AI Assistant Send Event Success',

package/src/services/config/Util.ts

@@ -189,7 +189,7 @@ function parseAgentConfigs(profileData: {
 
   const finalData = {
     teams: teamData,
-    defaultDn: userData.defaultDialledNumber,
+    defaultDn: userData.deafultDialledNumber,
     forceDefaultDn: tenantData.forceDefaultDn,
     forceDefaultDnForAgent: getDefaultAgentDN(agentProfileData.agentDNValidation),
     regexUS: tenantData.dnDefaultRegex,

package/src/services/config/constants.ts

@@ -166,7 +166,7 @@ export const endPointMap = {
   ) =>
     `organization/${orgId}/v2/auxiliary-code?page=${page}&pageSize=${pageSize}${
       filter && filter.length > 0 ? `&filter=id=in=(${filter})` : ''
-    }&attributes=${attributes}`,
+    }&attributes=${attributes}&desktopProfileFilter=true`,
 
   /**
    * Gets the endpoint for organization info.

package/src/services/config/types.ts

@@ -117,6 +117,10 @@ export const CC_TASK_EVENTS = {
   CAMPAIGN_CONTACT_UPDATED: 'CampaignContactUpdated',
   /** Event emitted when accepting a campaign preview contact fails */
   CAMPAIGN_PREVIEW_ACCEPT_FAILED: 'CampaignPreviewAcceptFailed',
+  /** Event emitted when skipping a campaign preview contact fails */
+  CAMPAIGN_PREVIEW_SKIP_FAILED: 'CampaignPreviewSkipFailed',
+  /** Event emitted when removing a campaign preview contact fails */
+  CAMPAIGN_PREVIEW_REMOVE_FAILED: 'CampaignPreviewRemoveFailed',
   /** Event emitted when a real-time transcript chunk is received */
   REAL_TIME_TRANSCRIPTION: 'REAL_TIME_TRANSCRIPTION',
 } as const;
@@ -275,8 +279,9 @@ export type AgentResponse = {
 
   /**
    * The default dialed number of the agent.
+   * Note: The API returns this field as "deafultDialledNumber" (with typo).
    */
-  defaultDialledNumber?: string;
+  deafultDialledNumber?: string;
 };
 
 /**

package/src/services/core/Err.ts

@@ -39,6 +39,8 @@ export type TaskErrorIds =
   | {'Service.aqm.task.resumeRecording': Failure}
   | {'Service.aqm.dialer.startOutdial': Failure}
   | {'Service.aqm.dialer.acceptPreviewContact': Failure}
+  | {'Service.aqm.dialer.skipPreviewContact': Failure}
+  | {'Service.aqm.dialer.removePreviewContact': Failure}
   | {'Service.reqs.generic.failure': {trackingId: string}};
 
 export type ReqError =

package/src/services/core/Utils.ts

@@ -49,34 +49,69 @@ const getAgentActionTypeFromTask = (taskData?: TaskData): 'DIAL_NUMBER' | '' =>
   return isDialNumber || isEntryPointVariant ? 'DIAL_NUMBER' : '';
 };
 
-// Fallback regex for US/Canada dial numbers when no dial plan entries are configured
-export const FALLBACK_DIAL_NUMBER_REGEX = /1[0-9]{3}[2-9][0-9]{6}([,]{1,10}[0-9]+){0,1}/;
+/**
+ * Strips characters defined in the dial plan entry from the input string.
+ *
+ * @param input - The dial number to sanitize
+ * @param strippedChars - String of characters to remove from the input
+ * @returns The sanitized input with specified characters removed
+ */
+export const stripDialPlanChars = (input: string, strippedChars: string): string => {
+  if (!strippedChars) {
+    return input;
+  }
+
+  const charsToStrip = new Set(strippedChars.split(''));
+
+  return input
+    .split('')
+    .filter((c) => !charsToStrip.has(c))
+    .join('');
+};
 
 /**
  * Validates a dial number against the provided dial plan regex patterns.
  * A number is valid if it matches at least one regex pattern in the dial plans.
- * Falls back to US/Canada regex validation if no dial plan entries are configured.
+ * Skips validation when no dial plan entries are configured, deferring to the server.
  *
  * @param input - The dial number to validate
  * @param dialPlanEntries - Array of dial plan entries containing regex patterns
- * @returns true if the input matches at least one dial plan regex pattern, false otherwise
+ * @returns true if the input matches at least one dial plan regex pattern or no entries are configured, false otherwise
  */
 export const isValidDialNumber = (
   input: string,
   dialPlanEntries: DialPlan['dialPlanEntity']
 ): boolean => {
+  if (!input) {
+    LoggerProxy.warn('Dial number is empty or undefined.', {
+      module: 'Utils',
+      method: 'isValidDialNumber',
+    });
+
+    return false;
+  }
+
   if (!dialPlanEntries || dialPlanEntries.length === 0) {
-    LoggerProxy.info('No dial plan entries found. Falling back to US number validation.');
+    LoggerProxy.log(
+      'No dial plan entries found. Skipping client-side validation, deferring to server.',
+      {module: 'Utils', method: 'isValidDialNumber'}
+    );
 
-    return FALLBACK_DIAL_NUMBER_REGEX.test(input);
+    return true;
   }
 
   return dialPlanEntries.some((entry) => {
     try {
+      const sanitizedInput = stripDialPlanChars(input, entry.strippedChars);
       const regex = new RegExp(entry.regex);
 
-      return regex.test(input);
-    } catch {
+      return regex.test(sanitizedInput);
+    } catch (e) {
+      LoggerProxy.warn(`Failed to validate dial number against entry "${entry.name}": ${e}`, {
+        module: 'Utils',
+        method: 'isValidDialNumber',
+      });
+
       return false;
     }
   });

package/src/services/task/TaskManager.ts

@@ -312,14 +312,11 @@ export default class TaskManager extends EventEmitter {
           case CC_EVENTS.AGENT_CONTACT_OFFER_RONA:
           case CC_EVENTS.AGENT_CONTACT_ASSIGN_FAILED:
           case CC_EVENTS.AGENT_INVITE_FAILED: {
-            LoggerProxy.warn(
-              `[DEBUG-CAMPAIGN-CLEAR] Task removal triggered by ${payload.data.type}, interactionId=${payload.data.interactionId}, taskType=${task?.data?.type}`,
-              {
-                module: TASK_MANAGER_FILE,
-                method: METHODS.REGISTER_TASK_LISTENERS,
-                interactionId: payload.data.interactionId,
-              }
-            );
+            LoggerProxy.info(`Task removal triggered by ${payload.data.type}`, {
+              module: TASK_MANAGER_FILE,
+              method: METHODS.REGISTER_TASK_LISTENERS,
+              interactionId: payload.data.interactionId,
+            });
             task = this.updateTaskData(task, payload.data);
 
             const eventTypeToMetricMap: Record<string, keyof typeof METRIC_EVENT_NAMES> = {
@@ -343,19 +340,31 @@ export default class TaskManager extends EventEmitter {
             break;
           }
           case CC_EVENTS.CONTACT_ENDED:
-            // Update task data
+            // Update task data.
             if (task) {
-              LoggerProxy.warn(
-                `[DEBUG-CAMPAIGN-CLEAR] CONTACT_ENDED, interactionId=${payload.data.interactionId}, taskType=${task?.data?.type}, state=${task?.data?.interaction?.state}`,
-                {
-                  module: TASK_MANAGER_FILE,
-                  method: METHODS.REGISTER_TASK_LISTENERS,
-                  interactionId: payload.data.interactionId,
-                }
+              LoggerProxy.info(`Contact ended for interaction`, {
+                module: TASK_MANAGER_FILE,
+                method: METHODS.REGISTER_TASK_LISTENERS,
+                interactionId: payload.data.interactionId,
+              });
+
+              // Campaign preview tasks should never trigger wrapup on ContactEnded —
+              // they are terminal cleanup events. For all other tasks, derive
+              // wrapUpRequired from agentsPendingWrapUp as before.
+              const CAMPAIGN_OUTBOUND_TYPES = [
+                'STANDARD_PREVIEW_CAMPAIGN',
+                'DIRECT_PREVIEW_CAMPAIGN',
+              ];
+              const isCampaignPreview = CAMPAIGN_OUTBOUND_TYPES.includes(
+                task.data?.interaction?.outboundType ?? ''
               );
+              const wrapUpRequired = isCampaignPreview
+                ? false
+                : payload.data.agentsPendingWrapUp?.includes(this.agentId) || false;
+
               task = this.updateTaskData(task, {
                 ...payload.data,
-                wrapUpRequired: payload.data.agentsPendingWrapUp?.includes(this.agentId) || false,
+                wrapUpRequired,
               });
 
               // Handle cleanup based on whether task should be deleted
@@ -364,12 +373,83 @@ export default class TaskManager extends EventEmitter {
               task?.emit(TASK_EVENTS.TASK_END, task);
             }
             break;
-          case CC_EVENTS.CAMPAIGN_CONTACT_UPDATED:
-            // CampaignContactUpdated is a non-terminal event (intermediate update during accept).
-            // Only update the task data — do NOT remove the task or emit TASK_END.
-            // Task cleanup is handled by CONTACT_ENDED or other terminal events.
+          case CC_EVENTS.CAMPAIGN_CONTACT_UPDATED: {
+            // CampaignContactUpdated is a non-terminal event (e.g., next contact after skip/remove).
+            // Update the task data and emit an event so consumers can react to the updated contact.
+            // Do NOT remove the task or emit TASK_END — cleanup is handled by CONTACT_ENDED.
             if (task) {
-              task = this.updateTaskData(task, payload.data);
+              // Carry forward campaign preview fields from existing task data since the updated
+              // contact payload may not include them, and reconcileData would delete them.
+              const existingCpd = task.data?.interaction?.callProcessingDetails;
+              const updatedData = {...payload.data};
+
+              if (existingCpd) {
+                const campaignFields = {
+                  ...(existingCpd.campaignPreviewAutoAction && {
+                    campaignPreviewAutoAction: existingCpd.campaignPreviewAutoAction,
+                  }),
+                  ...(existingCpd.campaignPreviewOfferTimeout && {
+                    campaignPreviewOfferTimeout: existingCpd.campaignPreviewOfferTimeout,
+                  }),
+                  ...(existingCpd.campaignPreviewSkipDisabled && {
+                    campaignPreviewSkipDisabled: existingCpd.campaignPreviewSkipDisabled,
+                  }),
+                  ...(existingCpd.campaignPreviewRemoveDisabled && {
+                    campaignPreviewRemoveDisabled: existingCpd.campaignPreviewRemoveDisabled,
+                  }),
+                };
+
+                if (!updatedData.interaction) {
+                  updatedData.interaction = {} as typeof updatedData.interaction;
+                }
+
+                updatedData.interaction = {
+                  ...updatedData.interaction,
+                  callProcessingDetails: {
+                    ...campaignFields,
+                    ...(updatedData.interaction.callProcessingDetails || {}),
+                  } as typeof existingCpd,
+                };
+              }
+
+              LoggerProxy.log('Campaign contact updated - carrying forward preview fields', {
+                module: TASK_MANAGER_FILE,
+                method: METHODS.REGISTER_TASK_LISTENERS,
+                interactionId: payload.data.interactionId,
+                data: {
+                  hasCpd: !!updatedData.interaction?.callProcessingDetails,
+                  autoAction:
+                    updatedData.interaction?.callProcessingDetails?.campaignPreviewAutoAction,
+                  skipDisabled:
+                    updatedData.interaction?.callProcessingDetails?.campaignPreviewSkipDisabled,
+                  removeDisabled:
+                    updatedData.interaction?.callProcessingDetails?.campaignPreviewRemoveDisabled,
+                },
+              });
+
+              task = this.updateTaskData(task, updatedData);
+              task.emit(TASK_EVENTS.TASK_CAMPAIGN_CONTACT_UPDATED, task);
+            }
+            break;
+          }
+          case CC_EVENTS.CAMPAIGN_PREVIEW_ACCEPT_FAILED:
+            if (task) {
+              // Failure payloads are sparse (no interaction field). Spread existing
+              // task data first so reconcileData doesn't delete interaction/cpd.
+              task = this.updateTaskData(task, {...task.data, ...payload.data});
+              task.emit(TASK_EVENTS.TASK_CAMPAIGN_PREVIEW_ACCEPT_FAILED, task);
+            }
+            break;
+          case CC_EVENTS.CAMPAIGN_PREVIEW_SKIP_FAILED:
+            if (task) {
+              task = this.updateTaskData(task, {...task.data, ...payload.data});
+              task.emit(TASK_EVENTS.TASK_CAMPAIGN_PREVIEW_SKIP_FAILED, task);
+            }
+            break;
+          case CC_EVENTS.CAMPAIGN_PREVIEW_REMOVE_FAILED:
+            if (task) {
+              task = this.updateTaskData(task, {...task.data, ...payload.data});
+              task.emit(TASK_EVENTS.TASK_CAMPAIGN_PREVIEW_REMOVE_FAILED, task);
             }
             break;
           case CC_EVENTS.CONTACT_MERGED:

package/src/services/task/constants.ts

@@ -24,6 +24,8 @@ export const CONFERENCE_EXIT = '/conference/exit';
 export const CONFERENCE_TRANSFER = '/conference/transfer';
 export const DIALER_API = '/v1/dialer';
 export const CAMPAIGN_PREVIEW_ACCEPT = '/accept';
+export const CAMPAIGN_PREVIEW_SKIP = '/skip';
+export const CAMPAIGN_PREVIEW_REMOVE = '/remove';
 /** 80-second timeout for accepting preview contact (outbound call setup takes longer than default 20s) */
 export const TIMEOUT_PREVIEW_ACCEPT = 80000;
 export const TASK_MANAGER_FILE = 'taskManager';