@webex/contact-center 3.11.0 → 3.12.0-mobius-socket.2

package/src/services/task/TaskManager.ts

@@ -5,9 +5,9 @@ import routingContact from './contact';
 import WebCallingService from '../WebCallingService';
 import {ITask, MEDIA_CHANNEL, TASK_EVENTS, TaskData, TaskId} from './types';
 import {TASK_MANAGER_FILE} from '../../constants';
-import {METHODS} from './constants';
+import {METHODS, TRANSCRIPT_EVENT_MAP} from './constants';
 import {CC_EVENTS, CC_TASK_EVENTS, WrapupData} from '../config/types';
-import {LoginOption} from '../../types';
+import {AIAssistantEventName, AIAssistantEventType, LoginOption} from '../../types';
 import LoggerProxy from '../../logger-proxy';
 import Task from '.';
 import MetricsManager from '../../metrics/MetricsManager';
@@ -15,11 +15,13 @@ import {METRIC_EVENT_NAMES} from '../../metrics/constants';
 import {
   checkParticipantNotInInteraction,
   getIsConferenceInProgress,
+  isCampaignPreviewReservation,
   isParticipantInMainInteraction,
   isPrimary,
   isSecondaryEpDnAgent,
   shouldAutoAnswerTask,
 } from './TaskUtils';
+import ApiAIAssistant from '../ApiAiAssistant';
 
 /** @internal */
 export default class TaskManager extends EventEmitter {
@@ -38,17 +40,20 @@ export default class TaskManager extends EventEmitter {
   private wrapupData: WrapupData;
   private agentId: string;
   private webRtcEnabled: boolean;
+  private apiAIAssistant?: ApiAIAssistant;
   /**
    * @param contact - Routing Contact layer. Talks to AQMReq layer to convert events to promises
    * @param webCallingService - Webrtc Service Layer
    * @param webSocketManager - Websocket Manager to maintain websocket connection and keepalives
    */
   constructor(
+    apiAIAssistant: ApiAIAssistant,
     contact: ReturnType<typeof routingContact>,
     webCallingService: WebCallingService,
     webSocketManager: WebSocketManager
   ) {
     super();
+    this.apiAIAssistant = apiAIAssistant;
     this.contact = contact;
     this.taskCollection = {};
     this.webCallingService = webCallingService;
@@ -79,9 +84,39 @@ export default class TaskManager extends EventEmitter {
     this.webRtcEnabled = webRtcEnabled;
   }
 
+  public handleRealtimeWebsocketEvent(event: string) {
+    try {
+      const payload = JSON.parse(event);
+
+      const eventType = payload?.type || payload?.data?.notifType;
+      const interactionId = payload?.data?.data?.conversationId;
+      if (!eventType || !interactionId) return;
+
+      const task = this.taskCollection[interactionId];
+      if (!task) {
+        LoggerProxy.info(`Realtime transcription task not found`, {
+          module: TASK_MANAGER_FILE,
+          method: METHODS.HANDLE_REAL_TIME_WEBSOCKET_EVENT,
+          interactionId,
+        });
+
+        return;
+      }
+
+      task.emit(eventType, payload.data);
+    } catch (error) {
+      LoggerProxy.error('Failed to parse RTD WebSocket message', {
+        module: TASK_MANAGER_FILE,
+        method: METHODS.HANDLE_REAL_TIME_WEBSOCKET_EVENT,
+        error,
+      });
+    }
+  }
+
   private handleIncomingWebCall = (call: ICall) => {
     const currentTask = Object.values(this.taskCollection).find(
-      (task) => task.data.interaction.mediaType === 'telephony'
+      (task) =>
+        task.data.interaction.mediaType === 'telephony' && !isCampaignPreviewReservation(task)
     );
 
     if (currentTask) {
@@ -109,9 +144,11 @@ export default class TaskManager extends EventEmitter {
       const payload = JSON.parse(event);
       // Re-emit the task events to the task object
       let task: ITask;
-      if (payload.data?.type) {
-        if (Object.values(CC_TASK_EVENTS).includes(payload.data.type)) {
-          task = this.taskCollection[payload.data.interactionId];
+      if (payload.data?.type || payload.type) {
+        if (Object.values(CC_TASK_EVENTS).includes(payload.data.type || payload.type)) {
+          task =
+            this.taskCollection[payload.data?.interactionId] ||
+            this.taskCollection[payload.data?.data?.conversationId];
         }
         LoggerProxy.info(`Handling task event ${payload.data?.type}`, {
           module: TASK_MANAGER_FILE,
@@ -249,8 +286,21 @@ export default class TaskManager extends EventEmitter {
             }
             break;
           case CC_EVENTS.AGENT_CONTACT_ASSIGNED:
-            task = this.updateTaskData(task, payload.data);
-            task.emit(TASK_EVENTS.TASK_ASSIGNED, task);
+            // 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 && payload.data.reservationInteractionId) {
+              task = this.taskCollection[payload.data.reservationInteractionId];
+              if (task) {
+                // Re-key the task under the new interaction ID and remove the old entry
+                delete this.taskCollection[payload.data.reservationInteractionId];
+                this.taskCollection[payload.data.interactionId] = task;
+              }
+            }
+            if (task) {
+              task = this.updateTaskData(task, payload.data);
+              task.emit(TASK_EVENTS.TASK_ASSIGNED, task);
+            }
             break;
           case CC_EVENTS.AGENT_CONTACT_UNASSIGNED:
             task = this.updateTaskData(task, {
@@ -262,6 +312,14 @@ 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,
+              }
+            );
             task = this.updateTaskData(task, payload.data);
 
             const eventTypeToMetricMap: Record<string, keyof typeof METRIC_EVENT_NAMES> = {
@@ -287,11 +345,17 @@ export default class TaskManager extends EventEmitter {
           case CC_EVENTS.CONTACT_ENDED:
             // 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,
+                }
+              );
               task = this.updateTaskData(task, {
                 ...payload.data,
-                wrapUpRequired:
-                  payload.data.interaction.state !== 'new' &&
-                  !isSecondaryEpDnAgent(payload.data.interaction),
+                wrapUpRequired: payload.data.agentsPendingWrapUp?.includes(this.agentId) || false,
               });
 
               // Handle cleanup based on whether task should be deleted
@@ -300,6 +364,14 @@ 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.
+            if (task) {
+              task = this.updateTaskData(task, payload.data);
+            }
+            break;
           case CC_EVENTS.CONTACT_MERGED:
             task = this.handleContactMerged(task, payload.data);
             break;
@@ -482,12 +554,55 @@ export default class TaskManager extends EventEmitter {
             task = this.updateTaskData(task, payload.data);
             task.emit(TASK_EVENTS.TASK_POST_CALL_ACTIVITY, task);
             break;
+          case CC_EVENTS.AGENT_OFFER_CAMPAIGN_RESERVATION: {
+            // Campaign preview contact offered to agent
+            // Create a task in the collection so subsequent events (e.g. AGENT_CONTACT_ASSIGNED
+            // after acceptPreviewContact) can find and update it.
+            // Emit TASK_CAMPAIGN_PREVIEW_RESERVATION instead of TASK_INCOMING so the call
+            // does not ring out to the customer before the agent explicitly accepts the preview contact.
+            LoggerProxy.log('Campaign preview reservation received', {
+              module: TASK_MANAGER_FILE,
+              method: METHODS.REGISTER_TASK_LISTENERS,
+              interactionId: payload.data.interactionId,
+            });
+
+            if (!this.taskCollection[payload.data.interactionId]) {
+              task = new Task(
+                this.contact,
+                this.webCallingService,
+                {
+                  ...payload.data,
+                  wrapUpRequired: false,
+                  isConferenceInProgress: false,
+                  isAutoAnswering: false,
+                },
+                this.wrapupData,
+                this.agentId
+              );
+              this.taskCollection[payload.data.interactionId] = task;
+            } else {
+              task = this.updateTaskData(task, payload.data);
+            }
+
+            this.emit(TASK_EVENTS.TASK_CAMPAIGN_PREVIEW_RESERVATION, task);
+            break;
+          }
+
           default:
             break;
         }
         if (task) {
           task.emit(payload.data.type, payload.data);
         }
+
+        const transcriptInteractionId =
+          payload.data?.interactionId ||
+          payload.data?.data?.conversationId ||
+          task?.data?.interactionId;
+
+        if (TRANSCRIPT_EVENT_MAP[payload.data.type] && transcriptInteractionId) {
+          this.requestRealTimeTranscripts(payload.data.type, transcriptInteractionId);
+        }
       }
     });
   }
@@ -662,23 +777,54 @@ 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);
     }
   }
 
   /**
-   * @param taskId - Unique identifier for each task
+   * Sends transcript start/stop event based on the CC event type.
+   * Fire-and-forget; errors are logged but do not interrupt event processing.
    */
-  public getTask = (taskId: string) => {
+  private requestRealTimeTranscripts(eventType: string, interactionId: string): void {
+    const action = TRANSCRIPT_EVENT_MAP[eventType];
+    if (
+      !action ||
+      !this.apiAIAssistant ||
+      this.apiAIAssistant.aiFeature?.realtimeTranscripts?.enable === false
+    )
+      return;
+
+    this.apiAIAssistant
+      .sendEvent(
+        this.agentId,
+        interactionId,
+        AIAssistantEventType.CUSTOM_EVENT,
+        AIAssistantEventName.GET_TRANSCRIPTS,
+        action
+      )
+      .catch((error) => {
+        LoggerProxy.error(`Failed to send transcript ${action} event`, {
+          module: TASK_MANAGER_FILE,
+          method: 'requestRealTimeTranscripts',
+          interactionId,
+          error,
+        });
+      });
+  }
+
+  public getTask(taskId: TaskId): ITask {
     return this.taskCollection[taskId];
-  };
+  }
 
   /**
    * @param taskId - Unique identifier for each task
@@ -687,20 +833,21 @@ export default class TaskManager extends EventEmitter {
     return this.taskCollection;
   };
 
-  /**
-   * @param contact - Routing Contact layer. Talks to AQMReq layer to convert events to promises
-   * @param webCallingService - Webrtc Service Layer
-   * @param webSocketManager - Websocket Manager to maintain websocket connection and keepalives
-   */
-  public static getTaskManager = (
+  public static getTaskManager(
+    apiAIAssistant: ApiAIAssistant,
     contact: ReturnType<typeof routingContact>,
     webCallingService: WebCallingService,
     webSocketManager: WebSocketManager
-  ): TaskManager => {
-    if (!this.taskManager) {
-      this.taskManager = new TaskManager(contact, webCallingService, webSocketManager);
+  ): TaskManager {
+    if (!TaskManager.taskManager) {
+      TaskManager.taskManager = new TaskManager(
+        apiAIAssistant,
+        contact,
+        webCallingService,
+        webSocketManager
+      );
     }
 
     return this.taskManager;
-  };
+  }
 }

package/src/services/task/TaskUtils.ts

@@ -1,5 +1,6 @@
 /* eslint-disable import/prefer-default-export */
 import {Interaction, ITask, TaskData, MEDIA_CHANNEL} from './types';
+import {CC_EVENTS} from '../config/types';
 import {OUTDIAL_DIRECTION, OUTDIAL_MEDIA_TYPE, OUTBOUND_TYPE} from '../../constants';
 import {LoginOption} from '../../types';
 
@@ -219,3 +220,14 @@ export const shouldAutoAnswerTask = (
 
   return false;
 };
+
+/**
+ * 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

@@ -4,6 +4,8 @@
  * @ignore
  */
 
+import {CC_EVENTS} from '../config/types';
+
 export const TASK_MESSAGE_TYPE = 'RoutingMessage';
 export const TASK_API = '/v1/tasks/';
 export const HOLD = '/hold';
@@ -20,6 +22,10 @@ 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';
+/** 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';
 
@@ -69,6 +75,7 @@ export const METHODS = {
   // TaskManager class methods
   HANDLE_INCOMING_WEB_CALL: 'handleIncomingWebCall',
   REGISTER_TASK_LISTENERS: 'registerTaskListeners',
+  HANDLE_REAL_TIME_WEBSOCKET_EVENT: 'handleRealtimeWebsocketEvent',
   REMOVE_TASK_FROM_COLLECTION: 'removeTaskFromCollection',
   HANDLE_TASK_CLEANUP: 'handleTaskCleanup',
   GET_TASK: 'getTask',
@@ -77,3 +84,12 @@ export const METHODS = {
   SETUP_AUTO_WRAPUP_TIMER: 'setupAutoWrapupTimer',
   CANCEL_AUTO_WRAPUP_TIMER: 'cancelAutoWrapupTimer',
 };
+
+export const TRANSCRIPT_EVENT_MAP = {
+  [CC_EVENTS.AGENT_CONTACT_ASSIGNED]: 'START',
+  [CC_EVENTS.AGENT_CONSULTING]: 'START',
+  [CC_EVENTS.AGENT_CONSULT_CONFERENCED]: 'START',
+  [CC_EVENTS.AGENT_WRAPUP]: 'STOP',
+  [CC_EVENTS.AGENT_CONSULT_ENDED]: 'STOP',
+  [CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE]: 'STOP',
+};

package/src/services/task/dialer.ts

@@ -1,7 +1,14 @@
 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,
+  TIMEOUT_PREVIEW_ACCEPT,
+} from './constants';
 import * as Contact from './types';
 import AqmReqs from '../core/aqm-reqs';
 
@@ -48,5 +55,53 @@ 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',
+      },
+    })),
   };
 }

package/src/services/task/types.ts

@@ -542,6 +542,18 @@ export enum TASK_EVENTS {
    * ```
    */
   TASK_POST_CALL_ACTIVITY = 'task:postCallActivity',
+
+  /**
+   * Triggered when a campaign preview contact is offered to the agent
+   * @example
+   * ```typescript
+   * task.on(TASK_EVENTS.TASK_CAMPAIGN_PREVIEW_RESERVATION, (data: AgentContact) => {
+   *   console.log('Campaign preview contact received:', data.interactionId);
+   *   // Handle campaign preview reservation
+   * });
+   * ```
+   */
+  TASK_CAMPAIGN_PREVIEW_RESERVATION = 'task:campaignPreviewReservation',
 }
 
 /**
@@ -1117,6 +1129,18 @@ export type DialerPayload = {
   origin: string;
 };
 
+/**
+ * Payload for campaign preview contact operations (accept, skip, remove)
+ * @public
+ */
+export type PreviewContactPayload = {
+  /** The interaction ID from the campaign reservation */
+  interactionId: string;
+  /** The campaign name (not a UUID). Available from the reservation event at
+   *  `task.data.interaction.callProcessingDetails.campaignId` or `task.data.campaignId`. */
+  campaignId: string;
+};
+
 /**
  * Data structure for cleaning up contact resources
  * @public

package/src/types.ts

@@ -295,6 +295,8 @@ interface IWebexInternal {
     get: (service: string) => string;
     /** Wait for service catalog to be loaded */
     waitForCatalog: (service: string) => Promise<void>;
+    /** Check if current environment is INT (integration) */
+    isIntegrationEnvironment: () => boolean;
     /** Host catalog for service discovery */
     _hostCatalog: Record<string, ServiceHost[]>;
     /** Service URLs cache */
@@ -539,7 +541,8 @@ export type RequestBody =
   | Contact.ConsultTransferPayLoad
   | Contact.cancelCtq
   | Contact.WrapupPayLoad
-  | Contact.DialerPayload;
+  | Contact.DialerPayload
+  | Contact.PreviewContactPayload;
 
 /**
  * Represents the options to fetch buddy agents for the logged in agent.
@@ -817,3 +820,39 @@ export type BuddyAgentsResponse = Agent.BuddyAgentsSuccess | Error;
  * function handleUpdateDeviceType(resp: UpdateDeviceTypeResponse) { ... }
  */
 export type UpdateDeviceTypeResponse = Agent.DeviceTypeUpdateSuccess | Error;
+
+export type TranscriptAction = 'START' | 'STOP';
+
+export const AIAssistantEventType = {
+  CUSTOM_EVENT: 'CUSTOM_EVENT',
+  CTI_EVENT: 'CTI_EVENT',
+} as const;
+
+export type AIAssistantEventType = Enum<typeof AIAssistantEventType>;
+
+export const AIAssistantEventName = {
+  GET_TRANSCRIPTS: 'GET_TRANSCRIPTS',
+  GET_MID_CALL_SUMMARY: 'GET_MID_CALL_SUMMARY',
+  GET_POST_CALL_SUMMARY: 'GET_POST_CALL_SUMMARY',
+  MID_CALL_SUMMARY_RESPONSE: 'MID_CALL_SUMMARY_RESPONSE',
+  POST_CALL_SUMMARY_RESPONSE: 'POST_CALL_SUMMARY_RESPONSE',
+  SUGGESTED_RESPONSES_DIGITAL: 'SUGGESTED_RESPONSES_DIGITAL',
+} as const;
+
+export type AIAssistantEventName = Enum<typeof AIAssistantEventName>;
+
+export type TranscriptMessage = {
+  role: string;
+  content: string;
+  messageId: string;
+  publishTimestamp: number;
+};
+
+export type HistoricTranscriptsResponse = {
+  orgId: string;
+  agentId: string;
+  conversationId: string | null;
+  interactionId: string;
+  source: string;
+  data: TranscriptMessage[];
+};