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

package/src/services/task/TaskManager.ts

@@ -19,7 +19,13 @@ import {METHODS, TRANSCRIPT_EVENT_MAP} from './constants';
 import {CC_EVENTS, WrapupData} from '../config/types';
 import {ConfigFlags, LoginOption, AIAssistantEventType, AIAssistantEventName} from '../../types';
 import LoggerProxy from '../../logger-proxy';
-import {getIsConferenceInProgress, isSecondaryEpDnAgent, shouldAutoAnswerTask} from './TaskUtils';
+import {
+  getIsConferenceInProgress,
+  isCampaignPreviewTask,
+  isCampaignPreviewReservation,
+  isSecondaryEpDnAgent,
+  shouldAutoAnswerTask,
+} from './TaskUtils';
 import TaskFactory from './TaskFactory';
 import WebRTC from './voice/WebRTC';
 import {TaskEvent, type TaskEventPayload} from './state-machine';
@@ -144,7 +150,8 @@ export default class TaskManager extends EventEmitter {
 
   private handleIncomingWebCall = (call: ICall) => {
     const currentTask = Object.values(this.taskCollection).find(
-      (t) => t.data.interaction.mediaType === MEDIA_CHANNEL.TELEPHONY
+      (task) =>
+        task.data.interaction.mediaType === 'telephony' && !isCampaignPreviewReservation(task)
     );
 
     if (currentTask) {
@@ -194,8 +201,23 @@ export default class TaskManager extends EventEmitter {
     switch (ccEvent) {
       // CC -> TaskEvent mappings (see TaskStateMachine comment for quick reference)
       case CC_EVENTS.AGENT_CONTACT_RESERVED: // AgentContactReserved -> TASK_INCOMING
+        if (isCampaignPreviewTask(payload)) {
+          return {
+            type: TaskEvent.TASK_INCOMING,
+            taskData: payload,
+            isCampaignReservationAccept: true,
+          };
+        }
+
         return {type: TaskEvent.TASK_INCOMING, taskData: payload};
 
+      case CC_EVENTS.AGENT_OFFER_CAMPAIGN_RESERVATION: // -> TASK_INCOMING (campaign branch via guard)
+        return {
+          type: TaskEvent.TASK_INCOMING,
+          taskData: payload,
+          isCampaignReservationAccept: true,
+        };
+
       case CC_EVENTS.AGENT_OFFER_CONTACT: // AgentOfferContact -> TASK_OFFERED
         return {type: TaskEvent.TASK_OFFERED, taskData: payload};
 
@@ -282,7 +304,9 @@ export default class TaskManager extends EventEmitter {
           type: TaskEvent.CONTACT_ENDED,
           taskData: {
             ...payload,
-            wrapUpRequired: payload.interaction?.state !== 'new',
+            wrapUpRequired: isCampaignPreviewTask(payload)
+              ? false
+              : payload.agentsPendingWrapUp?.includes(agentId || '') || false,
           },
         };
 
@@ -298,6 +322,15 @@ export default class TaskManager extends EventEmitter {
       case CC_EVENTS.AGENT_OUTBOUND_FAILED:
         return {type: TaskEvent.OUTBOUND_FAILED, taskData: payload, reason: payload.reason};
 
+      case CC_EVENTS.CAMPAIGN_PREVIEW_ACCEPT_FAILED:
+        return {type: TaskEvent.CAMPAIGN_PREVIEW_ACCEPT_FAILED, taskData: payload};
+
+      case CC_EVENTS.CAMPAIGN_PREVIEW_SKIP_FAILED:
+        return {type: TaskEvent.CAMPAIGN_PREVIEW_SKIP_FAILED, taskData: payload};
+
+      case CC_EVENTS.CAMPAIGN_PREVIEW_REMOVE_FAILED:
+        return {type: TaskEvent.CAMPAIGN_PREVIEW_REMOVE_FAILED, taskData: payload};
+
       case CC_EVENTS.CONTACT_RECORDING_STARTED:
         return {type: TaskEvent.RECORDING_STARTED, taskData: payload};
 
@@ -434,7 +467,20 @@ export default class TaskManager extends EventEmitter {
     }
 
     const interactionId = message.data.interactionId;
-    const task = this.taskCollection[interactionId];
+    const reservationInteractionId = message.data.reservationInteractionId;
+    let task = this.taskCollection[interactionId];
+
+    // When a campaign preview contact is accepted, the assigned event may arrive
+    // with a new interactionId while the task is stored under the original
+    // reservationInteractionId. Fall back to that key so the task is found.
+    if (!task && reservationInteractionId) {
+      task = this.taskCollection[reservationInteractionId];
+      if (task) {
+        // Re-key the task under the new interaction ID and remove the old entry
+        delete this.taskCollection[reservationInteractionId];
+        this.taskCollection[interactionId] = task;
+      }
+    }
 
     const wasConsultedTask = Boolean(task?.data?.isConsulted);
     const computeWrapUpRequired = () => {
@@ -503,11 +549,115 @@ export default class TaskManager extends EventEmitter {
       case CC_EVENTS.CONTACT_MERGED:
         return this.handleContactMergedEvent(context);
 
+      case CC_EVENTS.AGENT_OFFER_CAMPAIGN_RESERVATION:
+        return this.handleCampaignPreviewReservation(context);
+
+      case CC_EVENTS.CAMPAIGN_CONTACT_UPDATED:
+        return this.handleCampaignContactUpdated(context);
+
       default:
         return {task: context.task};
     }
   }
 
+  private handleCampaignContactUpdated(context: EventContext) {
+    const {payload} = context;
+    let {task} = context;
+    // 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) {
+      // 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: TaskData = {...payload};
+
+      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.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);
+    }
+
+    return {task};
+  }
+
+  /**
+   * Creates or updates a task for campaign preview reservation.
+   * TASK_CAMPAIGN_PREVIEW_RESERVATION is emitted by the state machine (campaign TASK_INCOMING branch).
+   */
+  private handleCampaignPreviewReservation(context: EventContext): TaskEventActions {
+    const {payload} = context;
+    let {task} = context;
+
+    LoggerProxy.log('Campaign preview reservation received', {
+      module: TASK_MANAGER_FILE,
+      method: METHODS.REGISTER_TASK_LISTENERS,
+      interactionId: payload.interactionId,
+    });
+
+    if (!task) {
+      task = TaskFactory.createTask(
+        this.contact,
+        this.webCallingService,
+        {
+          ...payload,
+          wrapUpRequired: false,
+          isConferenceInProgress: false,
+          isAutoAnswering: false,
+        },
+        this.configFlags,
+        this.wrapupData,
+        this.agentId
+      );
+      this.setupTaskListeners(task);
+      this.taskCollection[payload.interactionId] = task;
+    } else {
+      task = this.updateTaskData(task, payload);
+    }
+
+    return {task};
+  }
+
   /**
    * Handle AGENT_CONTACT_RESERVED event
    * Creates a new task; state machine event is sent during processing
@@ -624,6 +774,16 @@ export default class TaskManager extends EventEmitter {
       this.emit(TASK_EVENTS.TASK_INCOMING, t);
     });
 
+    task.on(TASK_EVENTS.TASK_CAMPAIGN_PREVIEW_RESERVATION, (t: ITask) => {
+      LoggerProxy.log(`Campaign preview reservation event received`, {
+        module: TASK_MANAGER_FILE,
+        method: METHODS.REGISTER_TASK_LISTENERS,
+        interactionId: t.data?.interactionId,
+      });
+
+      this.emit(TASK_EVENTS.TASK_CAMPAIGN_PREVIEW_RESERVATION, t);
+    });
+
     // Listen for TASK_HYDRATE on the task and re-emit on TaskManager
     task.on(TASK_EVENTS.TASK_HYDRATE, (t: ITask) => {
       // Task data is already updated by the task itself before emitting
@@ -735,6 +895,7 @@ export default class TaskManager extends EventEmitter {
    * @private
    */
   private handleTaskCleanup(task: ITask) {
+    // Clean up Desktop/WebRTC calling resources for browser-based telephony tasks
     if (
       this.webCallingService.loginOption === LoginOption.BROWSER &&
       task.data.interaction.mediaType === MEDIA_CHANNEL.TELEPHONY &&
@@ -746,13 +907,16 @@ export default class TaskManager extends EventEmitter {
 
     const isOutdial = task.data.interaction.outboundType === 'OUTDIAL';
     const isNew = task.data.interaction.state === 'new';
-    const needsWrapUp = task.data.agentsPendingWrapUp?.length > 0;
+    const needsWrapUp = task.data.agentsPendingWrapUp?.includes(this.agentId) ?? false;
 
     // For OUTDIAL: only remove if NOT terminated (user-declined, no wrap-up follows)
-    // If terminated, keep task for wrap-up flow (CONTACT_ENDED → AGENT_WRAPUP)
     // For non-OUTDIAL: remove if state is 'new'
     // Always remove if secondary EpDn agent
-    if ((isNew && !(isOutdial && needsWrapUp)) || isSecondaryEpDnAgent(task.data.interaction)) {
+    if (
+      (isNew && !(isOutdial && needsWrapUp)) ||
+      isSecondaryEpDnAgent(task.data.interaction) ||
+      (!needsWrapUp && isOutdial) // For outdial tasks, needs wrap-up is false and state is "WRAPUP". We need to just remove the task.
+    ) {
       this.removeTaskFromCollection(task);
     }
   }

package/src/services/task/TaskUtils.ts

@@ -1,9 +1,13 @@
 /* eslint-disable import/prefer-default-export */
 import {Interaction, ITask, TaskData, MEDIA_CHANNEL} from './types';
-import {OUTDIAL_DIRECTION, OUTDIAL_MEDIA_TYPE, OUTBOUND_TYPE} from '../../constants';
 import {LoginOption} from '../../types';
 import {PARTICIPANT_TYPE, MEDIA_TYPE_MAIN_CALL} from './state-machine/constants';
 import {TaskContext} from './state-machine/types';
+import {CC_EVENTS} from '../config/types';
+import {OUTBOUND_TYPE, OUTDIAL_DIRECTION, OUTDIAL_MEDIA_TYPE} from '../../constants';
+
+const CAMPAIGN_PREVIEW_OUTBOUND_TYPES = ['STANDARD_PREVIEW_CAMPAIGN', 'DIRECT_PREVIEW_CAMPAIGN'];
+const CAMPAIGN_PREVIEW_CAMPAIGN_TYPES = ['preview_standard', 'preview_direct'];
 
 /**
  * Checks if the customer is still in the call (not left)
@@ -240,6 +244,23 @@ export const isSecondaryEpDnAgent = (interaction: Interaction): boolean => {
   return interaction.mediaType === 'telephony' && isSecondaryAgent(interaction);
 };
 
+/**
+ * Checks if the task belongs to a campaign preview interaction.
+ * Campaign preview ContactEnded events are terminal cleanup events and should not trigger wrapup.
+ */
+export const isCampaignPreviewTask = (taskData?: TaskData | null): boolean => {
+  const outboundType = taskData?.interaction?.outboundType ?? '';
+  const cpd = taskData?.interaction?.callProcessingDetails as unknown as
+    | Record<string, string | undefined>
+    | undefined;
+  const campaignType = cpd?.campaignType ?? '';
+
+  return (
+    CAMPAIGN_PREVIEW_OUTBOUND_TYPES.includes(outboundType) ||
+    CAMPAIGN_PREVIEW_CAMPAIGN_TYPES.includes(campaignType)
+  );
+};
+
 /**
  * Checks if auto-answer is enabled for the agent participant
  * @param interaction - The interaction object
@@ -379,3 +400,14 @@ export const getConsultMediaResourceId = (
 
   return undefined;
 };
+
+/**
+ * Checks if a task is a campaign preview reservation that has not yet been accepted.
+ * Campaign preview tasks should not trigger incoming call handling until the agent
+ * explicitly accepts the preview contact.
+ * @param task - The task to check
+ * @returns true if the task is a pending campaign preview reservation, false otherwise
+ */
+export const isCampaignPreviewReservation = (task: ITask): boolean => {
+  return task?.data?.type === CC_EVENTS.AGENT_OFFER_CAMPAIGN_RESERVATION;
+};

package/src/services/task/constants.ts

@@ -22,6 +22,12 @@ export const END = '/end';
 export const CONSULT_CONFERENCE = '/consult/conference';
 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';
 export const TASK_FILE = 'task';
 

package/src/services/task/dialer.ts

@@ -1,7 +1,16 @@
 import {CC_EVENTS} from '../config/types';
 import {WCC_API_GATEWAY} from '../constants';
+import {HTTP_METHODS} from '../../types';
 import {createErrDetailsObject as err} from '../core/Utils';
-import {TASK_MESSAGE_TYPE, TASK_API} from './constants';
+import {
+  TASK_MESSAGE_TYPE,
+  TASK_API,
+  DIALER_API,
+  CAMPAIGN_PREVIEW_ACCEPT,
+  CAMPAIGN_PREVIEW_SKIP,
+  CAMPAIGN_PREVIEW_REMOVE,
+  TIMEOUT_PREVIEW_ACCEPT,
+} from './constants';
 import * as Contact from './types';
 import AqmReqs from '../core/aqm-reqs';
 
@@ -48,5 +57,131 @@ export default function aqmDialer(aqm: AqmReqs) {
         errId: 'Service.aqm.dialer.startOutdial',
       },
     })),
+
+    /**
+     * Accepts a campaign preview contact, initiating the outbound call.
+     *
+     * @param {Object} p - Parameters object.
+     * @param {Contact.PreviewContactPayload} p.data - Payload containing interactionId and campaignId.
+     * @returns {Promise<Contact.AgentContact>} A promise that resolves with agent contact on success.
+     *
+     * Emits:
+     * - `CC_EVENTS.AGENT_CONTACT_ASSIGNED` on success
+     * - `CC_EVENTS.CAMPAIGN_PREVIEW_ACCEPT_FAILED` on failure
+     * @ignore
+     */
+    acceptPreviewContact: aqm.req((p: {data: Contact.PreviewContactPayload}) => ({
+      url: `${DIALER_API}/campaign/${encodeURIComponent(p.data.campaignId)}/preview-task/${
+        p.data.interactionId
+      }${CAMPAIGN_PREVIEW_ACCEPT}`,
+      host: WCC_API_GATEWAY,
+      data: {},
+      method: HTTP_METHODS.POST,
+      timeout: TIMEOUT_PREVIEW_ACCEPT,
+      err,
+      notifSuccess: {
+        bind: {
+          type: TASK_MESSAGE_TYPE,
+          data: {
+            type: [CC_EVENTS.AGENT_CONTACT_ASSIGNED, CC_EVENTS.CONTACT_ENDED],
+            __typeMap: {
+              typeField: 'type',
+              conditions: {
+                [CC_EVENTS.AGENT_CONTACT_ASSIGNED]: {
+                  reservationInteractionId: p.data.interactionId,
+                },
+                [CC_EVENTS.CONTACT_ENDED]: {interactionId: p.data.interactionId},
+              },
+            },
+          },
+        },
+        msg: {} as Contact.AgentContact,
+      },
+      notifFail: {
+        bind: {
+          type: TASK_MESSAGE_TYPE,
+          data: {type: CC_EVENTS.CAMPAIGN_PREVIEW_ACCEPT_FAILED, campaignId: p.data.campaignId},
+        },
+        errId: 'Service.aqm.dialer.acceptPreviewContact',
+      },
+    })),
+
+    /**
+     * Skips a campaign preview contact, requesting the next contact from the campaign.
+     *
+     * @param {Object} p - Parameters object.
+     * @param {Contact.PreviewContactPayload} p.data - Payload containing interactionId and campaignId.
+     * @returns {Promise<Contact.AgentContact>} A promise that resolves with agent contact on success.
+     *
+     * Emits:
+     * - `CC_EVENTS.CAMPAIGN_CONTACT_UPDATED` or `CC_EVENTS.CONTACT_ENDED` on success
+     * - `CC_EVENTS.CAMPAIGN_PREVIEW_SKIP_FAILED` on failure
+     * @ignore
+     */
+    skipPreviewContact: aqm.req((p: {data: Contact.PreviewContactPayload}) => ({
+      url: `${DIALER_API}/campaign/${encodeURIComponent(p.data.campaignId)}/preview-task/${
+        p.data.interactionId
+      }${CAMPAIGN_PREVIEW_SKIP}`,
+      host: WCC_API_GATEWAY,
+      data: {},
+      method: HTTP_METHODS.POST,
+      err,
+      notifSuccess: {
+        bind: {
+          type: TASK_MESSAGE_TYPE,
+          data: {
+            type: [CC_EVENTS.CAMPAIGN_CONTACT_UPDATED, CC_EVENTS.CONTACT_ENDED],
+            interactionId: p.data.interactionId,
+          },
+        },
+        msg: {} as Contact.AgentContact,
+      },
+      notifFail: {
+        bind: {
+          type: TASK_MESSAGE_TYPE,
+          data: {type: CC_EVENTS.CAMPAIGN_PREVIEW_SKIP_FAILED, campaignId: p.data.campaignId},
+        },
+        errId: 'Service.aqm.dialer.skipPreviewContact',
+      },
+    })),
+
+    /**
+     * Removes a campaign preview contact from the campaign list entirely.
+     *
+     * @param {Object} p - Parameters object.
+     * @param {Contact.PreviewContactPayload} p.data - Payload containing interactionId and campaignId.
+     * @returns {Promise<Contact.AgentContact>} A promise that resolves with agent contact on success.
+     *
+     * Emits:
+     * - `CC_EVENTS.CAMPAIGN_CONTACT_UPDATED` or `CC_EVENTS.CONTACT_ENDED` on success
+     * - `CC_EVENTS.CAMPAIGN_PREVIEW_REMOVE_FAILED` on failure
+     * @ignore
+     */
+    removePreviewContact: aqm.req((p: {data: Contact.PreviewContactPayload}) => ({
+      url: `${DIALER_API}/campaign/${encodeURIComponent(p.data.campaignId)}/preview-task/${
+        p.data.interactionId
+      }${CAMPAIGN_PREVIEW_REMOVE}`,
+      host: WCC_API_GATEWAY,
+      data: {},
+      method: HTTP_METHODS.POST,
+      err,
+      notifSuccess: {
+        bind: {
+          type: TASK_MESSAGE_TYPE,
+          data: {
+            type: [CC_EVENTS.CAMPAIGN_CONTACT_UPDATED, CC_EVENTS.CONTACT_ENDED],
+            interactionId: p.data.interactionId,
+          },
+        },
+        msg: {} as Contact.AgentContact,
+      },
+      notifFail: {
+        bind: {
+          type: TASK_MESSAGE_TYPE,
+          data: {type: CC_EVENTS.CAMPAIGN_PREVIEW_REMOVE_FAILED, campaignId: p.data.campaignId},
+        },
+        errId: 'Service.aqm.dialer.removePreviewContact',
+      },
+    })),
   };
 }

package/src/services/task/state-machine/TaskStateMachine.ts

@@ -126,11 +126,18 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
               actions: ['updateTaskData', 'emitTaskHydrate'],
             },
           ],
-          // AgentContactReserved (applicable for direct incoming/consult/transfer/outdial)
-          [TaskEvent.TASK_INCOMING]: {
-            target: TaskState.OFFERED,
-            actions: ['initializeTask', 'emitTaskIncoming'],
-          },
+          // AgentContactReserved (direct incoming/consult/transfer/outdial, or campaign preview accept)
+          [TaskEvent.TASK_INCOMING]: [
+            {
+              guard: guards.isCampaignReservationAccept,
+              target: TaskState.OFFERED,
+              actions: ['initializeTask', 'emitTaskCampaignPreviewReservation'],
+            },
+            {
+              target: TaskState.OFFERED,
+              actions: ['initializeTask', 'emitTaskIncoming'],
+            },
+          ],
 
           // AgentOutboundFailed can arrive before TASK_INCOMING due to race conditions
           [TaskEvent.OUTBOUND_FAILED]: {
@@ -208,6 +215,15 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
               actions: ['updateTaskData', 'markEnded', 'emitTaskOutdialFailed', 'emitTaskEnd'],
             },
           ],
+          [TaskEvent.CAMPAIGN_PREVIEW_ACCEPT_FAILED]: {
+            actions: ['updateTaskData', 'emitTaskCampaignPreviewAcceptFailed'],
+          },
+          [TaskEvent.CAMPAIGN_PREVIEW_SKIP_FAILED]: {
+            actions: ['updateTaskData', 'emitTaskCampaignPreviewSkipFailed'],
+          },
+          [TaskEvent.CAMPAIGN_PREVIEW_REMOVE_FAILED]: {
+            actions: ['updateTaskData', 'emitTaskCampaignPreviewRemoveFailed'],
+          },
           // AgentConsulting comes for received after the initial consult is accepted
           [TaskEvent.CONSULTING_ACTIVE]: [
             {
@@ -266,6 +282,10 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
             ],
           },
           // AgentContactAssigned can be resent after consult transfers; keep context in sync
+          /* TODO: This transition needs to be checked if this is even needed as receiver will
+           * be in Consult Accept state which can be consulting state and ASSIGNED will be only
+           * for the receiver. So receuving ASSIGNED in Connected state is highly unlikely.
+           */
           [TaskEvent.ASSIGN]: {
             target: TaskState.CONNECTED,
             actions: ['updateTaskData', 'emitTaskAssigned'],
@@ -319,6 +339,12 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
           ],
           // AgentContactEnded Event
           [TaskEvent.CONTACT_ENDED]: [
+            {
+              // Campaign preview ContactEnded is terminal cleanup; never enter wrapup.
+              guard: guards.isCampaignPreviewContactEnded,
+              target: TaskState.TERMINATED,
+              actions: ['updateTaskData', 'markEnded', 'emitTaskEnd'],
+            },
             {
               // Conference still active → CONFERENCING
               guard: guards.conferenceInProgressFromEvent,
@@ -426,6 +452,12 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
             actions: ['updateTaskData'],
           },
           [TaskEvent.CONTACT_ENDED]: [
+            {
+              // Campaign preview ContactEnded is terminal cleanup; never enter wrapup.
+              guard: guards.isCampaignPreviewContactEnded,
+              target: TaskState.TERMINATED,
+              actions: ['updateTaskData', 'markEnded', 'emitTaskEnd'],
+            },
             {
               guard: guards.conferenceInProgressFromEvent,
               target: TaskState.CONFERENCING,

package/src/services/task/state-machine/actions.ts

@@ -651,6 +651,10 @@ export const actions: TaskActionsMap = {
   cleanupResources: () => undefined,
 
   // Event emitters - placeholders overridden by consumers
+  emitTaskCampaignPreviewReservation: () => undefined,
+  emitTaskCampaignPreviewAcceptFailed: () => undefined,
+  emitTaskCampaignPreviewSkipFailed: () => undefined,
+  emitTaskCampaignPreviewRemoveFailed: () => undefined,
   emitTaskIncoming: () => undefined,
   emitTaskHydrate: () => undefined,
   emitTaskOfferContact: () => undefined,

package/src/services/task/state-machine/constants.ts

@@ -153,6 +153,9 @@ export enum TaskEvent {
   ASSIGN_FAILED = 'ASSIGN_FAILED',
   INVITE_FAILED = 'INVITE_FAILED',
   OUTBOUND_FAILED = 'OUTBOUND_FAILED',
+  CAMPAIGN_PREVIEW_ACCEPT_FAILED = 'CAMPAIGN_PREVIEW_ACCEPT_FAILED',
+  CAMPAIGN_PREVIEW_SKIP_FAILED = 'CAMPAIGN_PREVIEW_SKIP_FAILED',
+  CAMPAIGN_PREVIEW_REMOVE_FAILED = 'CAMPAIGN_PREVIEW_REMOVE_FAILED',
 
   // Switch events (toggle between consult and main call)
   SWITCH_TO_MAIN_CALL = 'SWITCH_TO_MAIN_CALL',

package/src/services/task/state-machine/guards.ts

@@ -26,6 +26,7 @@ import {
   getIsCustomerInCall,
   getConferenceParticipantsCount,
   getIsConferenceInProgress,
+  isCampaignPreviewTask,
 } from '../TaskUtils';
 import {TaskEvent, INTERACTION_STATE, CONSULT_STATE, MEDIA_TYPE_CONSULT} from './constants';
 
@@ -296,6 +297,31 @@ export const guards = {
   },
 
   // Wrapup Guards
+  isCampaignPreviewContactEnded: ({context, event}: GuardParams): boolean => {
+    if (event?.type !== TaskEvent.CONTACT_ENDED) {
+      return false;
+    }
+
+    const taskData = getTaskDataFromEvent(event);
+    if (!isCampaignPreviewTask(taskData)) {
+      return false;
+    }
+
+    const selfAgentId = getSelfAgentId(context, taskData);
+    const pending = taskData?.agentsPendingWrapUp;
+    const isPendingWrapUp =
+      Array.isArray(pending) && !!selfAgentId && pending.includes(selfAgentId);
+    const participantIsWrapUp =
+      !!selfAgentId && taskData?.interaction?.participants?.[selfAgentId]?.isWrapUp === true;
+    const explicitWrapUp =
+      taskData?.wrapUpRequired === true ||
+      participantIsWrapUp ||
+      isPendingWrapUp ||
+      taskData?.interaction?.state === 'wrapUp';
+
+    return !explicitWrapUp;
+  },
+
   shouldWrapUp: ({context, event}: GuardParams): boolean => {
     const taskData = getTaskDataFromEvent(event);
     if (!taskData) return false;
@@ -362,6 +388,10 @@ export const guards = {
     return false;
   },
 
+  isCampaignReservationAccept: ({event}: GuardParams): boolean => {
+    return event?.type === TaskEvent.TASK_INCOMING && event.isCampaignReservationAccept === true;
+  },
+
   // Server State Guards
   isPrimaryMediaOnHold: ({event}: GuardParams): boolean => {
     const taskData = getTaskDataFromEvent(event);

package/src/services/task/state-machine/types.ts

@@ -84,7 +84,11 @@ type BaseEvent<T extends TaskEvent> = {type: T};
  * Event payload mapping - defines the payload for each event type
  */
 interface TaskEventPayloadMap {
-  [TaskEvent.TASK_INCOMING]: BaseEvent<TaskEvent.TASK_INCOMING> & {taskData: TaskData};
+  [TaskEvent.TASK_INCOMING]: BaseEvent<TaskEvent.TASK_INCOMING> & {
+    taskData: TaskData;
+    /** Set when campaign preview reservation accept is receieved */
+    isCampaignReservationAccept?: boolean;
+  };
   [TaskEvent.TASK_OFFERED]: BaseEvent<TaskEvent.TASK_OFFERED> & {taskData: TaskData};
   [TaskEvent.OFFER_CONSULT]: BaseEvent<TaskEvent.OFFER_CONSULT> & {taskData: TaskData};
   [TaskEvent.HYDRATE]: BaseEvent<TaskEvent.HYDRATE> & {taskData: TaskData; agentId?: string};
@@ -173,6 +177,15 @@ interface TaskEventPayloadMap {
     reason?: string;
     taskData?: TaskData;
   };
+  [TaskEvent.CAMPAIGN_PREVIEW_ACCEPT_FAILED]: BaseEvent<TaskEvent.CAMPAIGN_PREVIEW_ACCEPT_FAILED> & {
+    taskData?: TaskData;
+  };
+  [TaskEvent.CAMPAIGN_PREVIEW_SKIP_FAILED]: BaseEvent<TaskEvent.CAMPAIGN_PREVIEW_SKIP_FAILED> & {
+    taskData?: TaskData;
+  };
+  [TaskEvent.CAMPAIGN_PREVIEW_REMOVE_FAILED]: BaseEvent<TaskEvent.CAMPAIGN_PREVIEW_REMOVE_FAILED> & {
+    taskData?: TaskData;
+  };
   [TaskEvent.SWITCH_TO_MAIN_CALL]: BaseEvent<TaskEvent.SWITCH_TO_MAIN_CALL>;
   [TaskEvent.SWITCH_TO_CONSULT]: BaseEvent<TaskEvent.SWITCH_TO_CONSULT>;
   [TaskEvent.ACCEPT]: BaseEvent<TaskEvent.ACCEPT>;