@webex/contact-center 3.8.1 → 3.9.0-multi-llms.2

package/src/services/config/types.ts

@@ -45,6 +45,28 @@ export const CC_TASK_EVENTS = {
   AGENT_CONSULT_END_FAILED: 'AgentConsultEndFailed',
   /** Event emitted when consultation conference ends */
   AGENT_CONSULT_CONFERENCE_ENDED: 'AgentConsultConferenceEnded',
+  /** Event emitted when consultation conference is in progress */
+  AGENT_CONSULT_CONFERENCING: 'AgentConsultConferencing',
+  /** Event emitted when consultation conference starts */
+  AGENT_CONSULT_CONFERENCED: 'AgentConsultConferenced',
+  /** Event emitted when consultation conference fails */
+  AGENT_CONSULT_CONFERENCE_FAILED: 'AgentConsultConferenceFailed',
+  /** Event emitted when participant joins conference */
+  PARTICIPANT_JOINED_CONFERENCE: 'ParticipantJoinedConference',
+  /** Event emitted when participant leaves conference */
+  PARTICIPANT_LEFT_CONFERENCE: 'ParticipantLeftConference',
+  /** Event emitted when participant leaving conference fails */
+  PARTICIPANT_LEFT_CONFERENCE_FAILED: 'ParticipantLeftConferenceFailed',
+  /** Event emitted when consultation conference end fails */
+  AGENT_CONSULT_CONFERENCE_END_FAILED: 'AgentConsultConferenceEndFailed',
+  /** Event emitted when conference is successfully transferred */
+  AGENT_CONFERENCE_TRANSFERRED: 'AgentConferenceTransferred',
+  /** Event emitted when conference transfer fails */
+  AGENT_CONFERENCE_TRANSFER_FAILED: 'AgentConferenceTransferFailed',
+  /** Event emitted when consulted participant is moving/being transferred */
+  CONSULTED_PARTICIPANT_MOVING: 'ConsultedParticipantMoving',
+  /** Event emitted for post-call activity by participant */
+  PARTICIPANT_POST_CALL_ACTIVITY: 'ParticipantPostCallActivity',
   /** Event emitted when contact is blind transferred */
   AGENT_BLIND_TRANSFERRED: 'AgentBlindTransferred',
   /** Event emitted when blind transfer fails */
@@ -1052,66 +1074,45 @@ export type CallDistributionGroup = {
 };
 
 /**
- * Comprehensive configuration for a contact service queue
+ * Represents a single outdial ANI (Automatic Number Identification) entry
  * @public
  */
-export type ContactServiceQueue = {
-  /** Unique identifier for the queue */
+export type OutdialAniEntry = {
+  /** Unique identifier for the ANI entry */
   id: string;
-  /** Queue name */
+  /** Display name for the ANI entry */
   name: string;
-  /** Queue description */
-  description: string;
-  /** Type of queue */
-  queueType: string;
-  /** Whether to check agent availability before routing */
-  checkAgentAvailability: boolean;
-  /** Type of channel this queue handles */
-  channelType: string;
-  /** Service level threshold in seconds */
-  serviceLevelThreshold: number;
-  /** Maximum number of active contacts allowed */
-  maxActiveContacts: number;
-  /** Maximum time contacts can wait in queue (seconds) */
-  maxTimeInQueue: number;
-  /** Default music on hold media file ID */
-  defaultMusicInQueueMediaFileId: string;
-  /** Queue timezone */
-  timezone: string;
-  /** Whether queue is active */
-  active: boolean;
-  /** Whether outbound campaign routing is enabled */
-  outdialCampaignEnabled: boolean;
-  /** Whether monitoring is permitted */
-  monitoringPermitted: boolean;
-  /** Whether parking is permitted */
-  parkingPermitted: boolean;
-  /** Whether recording is permitted */
-  recordingPermitted: boolean;
-  /** Whether recording all calls is permitted */
-  recordingAllCallsPermitted: boolean;
-  /** Whether pausing recordings is permitted */
-  pauseRecordingPermitted: boolean;
-  /** Maximum recording pause duration in seconds */
-  recordingPauseDuration: number;
-  /** Control flow script URL */
-  controlFlowScriptUrl: string;
-  /** IVR requeue URL */
-  ivrRequeueUrl: string;
-  /** Type of routing strategy */
-  routingType: string;
-  /** Queue-specific routing type */
-  queueRoutingType: string;
-  /** Queue skill requirements for routing */
-  queueSkillRequirements: object[];
-  /** Associated agents */
-  agents: object[];
-  /** Call distribution group configurations */
-  callDistributionGroups: CallDistributionGroup[];
-  /** Associated resource links */
-  links: Array<string>;
-  /** Timestamp when queue was created */
-  createdTime: string;
-  /** Timestamp when queue was last updated */
-  lastUpdatedTime: string;
+  /** Phone number associated with this ANI entry */
+  number: string;
+  /** Related links for this ANI entry */
+  links: string[];
+  /** Timestamp when this entry was created (Unix timestamp in milliseconds) */
+  createdTime: number;
+  /** Timestamp when this entry was last updated (Unix timestamp in milliseconds) */
+  lastUpdatedTime: number;
+};
+
+/**
+ * Response structure for outdial ANI entries API call
+ * @public
+ */
+export type OutdialAniEntriesResponse = OutdialAniEntry[];
+
+/**
+ * Parameters for fetching outdial ANI entries
+ * @public
+ */
+export type OutdialAniParams = {
+  /** Outdial ANI ID from agent profile */
+  outdialANI: string;
+  /** Page number for pagination (optional) */
+  page?: number;
+  /** Number of entries per page (optional) */
+  pageSize?: number;
+  /** Search string to filter entries (optional) */
+  search?: string;
+  /** Filter expression for advanced filtering (optional) */
+  filter?: string;
+  /** Comma-separated list of attributes to include in response (optional) */
+  attributes?: string;
 };

package/src/services/core/GlobalTypes.ts

@@ -32,3 +32,30 @@ export type Failure = Msg<{
   /** Human-readable description of the failure reason */
   reason: string;
 }>;
+
+/**
+ * Represents task API error details in a structured format
+ * @public
+ */
+export interface TaskError {
+  /** Original error object for throwing */
+  error: Error;
+  /** Unique tracking identifier for correlation */
+  trackingId: string;
+  /** Detailed error message from the API */
+  errorMessage: string;
+  /** Type/category of the error (e.g., "Bad Request") */
+  errorType: string;
+  /** Additional error context data */
+  errorData: string;
+  /** Numeric reason code */
+  reasonCode: number;
+}
+
+/**
+ * An Error object augmented with a flexible data field for additional context.
+ * Use this to attach structured data to thrown errors without ts-ignore.
+ */
+export interface AugmentedError extends Error {
+  data?: Record<string, any>;
+}

package/src/services/core/Utils.ts

@@ -1,8 +1,16 @@
 import * as Err from './Err';
 import {LoginOption, WebexRequestPayload} from '../../types';
-import {Failure} from './GlobalTypes';
+import {Failure, AugmentedError} from './GlobalTypes';
 import LoggerProxy from '../../logger-proxy';
 import WebexRequest from './WebexRequest';
+import {
+  TaskData,
+  ConsultTransferPayLoad,
+  ConsultConferenceData,
+  consultConferencePayloadData,
+  CONSULT_TRANSFER_DESTINATION_TYPE,
+  Interaction,
+} from '../task/types';
 
 /**
  * Extracts common error details from a Webex request payload.
@@ -19,6 +27,28 @@ const getCommonErrorDetails = (errObj: WebexRequestPayload) => {
   };
 };
 
+/**
+ * Checks if the destination type represents an entry point variant (EPDN or ENTRYPOINT).
+ */
+const isEntryPointOrEpdn = (destAgentType?: string): boolean => {
+  return destAgentType === 'EPDN' || destAgentType === 'ENTRYPOINT';
+};
+
+/**
+ * Determines if the task involves dialing a number based on the destination type.
+ * Returns 'DIAL_NUMBER' for dial-related destinations, empty string otherwise.
+ */
+const getAgentActionTypeFromTask = (taskData?: TaskData): 'DIAL_NUMBER' | '' => {
+  const destAgentType = taskData?.destinationType;
+
+  // Check if destination requires dialing: direct dial number or entry point variants
+  const isDialNumber = destAgentType === 'DN';
+  const isEntryPointVariant = isEntryPointOrEpdn(destAgentType);
+
+  // If the destination type is a dial number or an entry point variant, return 'DIAL_NUMBER'
+  return isDialNumber || isEntryPointVariant ? 'DIAL_NUMBER' : '';
+};
+
 export const isValidDialNumber = (input: string): boolean => {
   // This regex checks for a valid dial number format for only few countries such as US, Canada.
   const regexForDn = /1[0-9]{3}[2-9][0-9]{6}([,]{1,10}[0-9]+){0,1}/;
@@ -115,6 +145,62 @@ export const getErrorDetails = (error: any, methodName: string, moduleName: stri
   };
 };
 
+/**
+ * Extracts error details from task API errors and logs them. Also uploads logs for the error.
+ * This handles the specific error format returned by task API calls.
+ *
+ * @param error - The error object from task API calls with structure: {id: string, details: {trackingId: string, msg: {...}}}
+ * @param methodName - The name of the method where the error occurred.
+ * @param moduleName - The name of the module where the error occurred.
+ * @returns AugmentedError containing structured error details on err.data for metrics and logging
+ * @public
+ * @example
+ * const taskError = generateTaskErrorObject(error, 'transfer', 'TaskModule');
+ * throw taskError.error;
+ * @ignore
+ */
+export const generateTaskErrorObject = (
+  error: any,
+  methodName: string,
+  moduleName: string
+): AugmentedError => {
+  const trackingId = error?.details?.trackingId || error?.trackingId || '';
+  const errorMsg = error?.details?.msg;
+
+  const fallbackMessage =
+    (error && typeof error.message === 'string' && error.message) ||
+    `Error while performing ${methodName}`;
+  const errorMessage = errorMsg?.errorMessage || fallbackMessage;
+  const errorType =
+    errorMsg?.errorType ||
+    (error && typeof error.name === 'string' && error.name) ||
+    'Unknown Error';
+  const errorData = errorMsg?.errorData || '';
+  const reasonCode = errorMsg?.reasonCode || 0;
+
+  // Log and upload for Task API formatted errors
+  LoggerProxy.error(`${methodName} failed: ${errorMessage} (${errorType})`, {
+    module: moduleName,
+    method: methodName,
+    trackingId,
+  });
+  WebexRequest.getInstance().uploadLogs({
+    correlationId: trackingId,
+  });
+
+  const reason = `${errorType}: ${errorMessage}${errorData ? ` (${errorData})` : ''}`;
+  const err: AugmentedError = new Error(reason);
+  err.data = {
+    message: errorMessage,
+    errorType,
+    errorData,
+    reasonCode,
+    trackingId,
+  };
+
+  return err;
+};
+
 /**
  * Creates an error details object suitable for use with the Err.Details class.
  *
@@ -130,3 +216,115 @@ export const createErrDetailsObject = (errObj: WebexRequestPayload) => {
 
   return new Err.Details('Service.reqs.generic.failure', details);
 };
+
+/**
+ * Derives the consult transfer destination type based on the provided task data.
+ *
+ * Logic parity with desktop behavior:
+ * - If agent action is dialing a number (DN/EPDN/ENTRYPOINT):
+ *   - ENTRYPOINT/EPDN map to ENTRYPOINT
+ *   - DN maps to DIALNUMBER
+ * - Otherwise defaults to AGENT
+ *
+ * @param taskData - The task data used to infer the agent action and destination type
+ * @returns The normalized destination type to be used for consult transfer
+ */
+/**
+ * Checks if a participant type represents a non-customer participant.
+ * Non-customer participants include agents, dial numbers, entry point dial numbers,
+ * and entry points.
+ */
+const isNonCustomerParticipant = (participantType: string): boolean => {
+  return (
+    participantType === 'Agent' ||
+    participantType === 'DN' ||
+    participantType === 'EpDn' ||
+    participantType === 'entryPoint'
+  );
+};
+
+/**
+ * Gets the destination agent ID from participants data by finding the first
+ * non-customer participant that is not the current agent and is not in wrap-up state.
+ *
+ * @param participants - The participants data from the interaction
+ * @param agentId - The current agent's ID to exclude from the search
+ * @returns The destination agent ID, or empty string if none found
+ */
+export const getDestinationAgentId = (
+  participants: Interaction['participants'],
+  agentId: string
+): string => {
+  let id = '';
+
+  if (participants) {
+    Object.keys(participants).forEach((participant) => {
+      const participantData = participants[participant];
+      if (
+        isNonCustomerParticipant(participantData.type) &&
+        participantData.id !== agentId &&
+        !participantData.isWrapUp
+      ) {
+        id = participantData.id;
+      }
+    });
+  }
+
+  return id;
+};
+
+export const deriveConsultTransferDestinationType = (
+  taskData?: TaskData
+): ConsultTransferPayLoad['destinationType'] => {
+  const agentActionType = getAgentActionTypeFromTask(taskData);
+
+  if (agentActionType === 'DIAL_NUMBER') {
+    return isEntryPointOrEpdn(taskData?.destinationType)
+      ? CONSULT_TRANSFER_DESTINATION_TYPE.ENTRYPOINT
+      : CONSULT_TRANSFER_DESTINATION_TYPE.DIALNUMBER;
+  }
+
+  return CONSULT_TRANSFER_DESTINATION_TYPE.AGENT;
+};
+
+/**
+ * Builds consult conference parameter data using EXACT Agent Desktop logic.
+ * This matches the Agent Desktop's consultConference implementation exactly.
+ *
+ * @param dataPassed - Original consultation data from Agent Desktop format
+ * @param interactionIdPassed - The interaction ID for the task
+ * @returns Object with interactionId and ConsultConferenceData matching Agent Desktop format
+ * @public
+ */
+export const buildConsultConferenceParamData = (
+  dataPassed: consultConferencePayloadData,
+  interactionIdPassed: string
+): {interactionId: string; data: ConsultConferenceData} => {
+  const data: ConsultConferenceData = {
+    // Include agentId if present in input data
+    ...('agentId' in dataPassed && {agentId: dataPassed.agentId}),
+    // Handle destAgentId from consultation data
+    to: dataPassed.destAgentId,
+    destinationType: '',
+  };
+
+  // Agent Desktop destination type logic
+  if ('destinationType' in dataPassed) {
+    if (dataPassed.destinationType === 'DN') {
+      data.destinationType = CONSULT_TRANSFER_DESTINATION_TYPE.DIALNUMBER;
+    } else if (dataPassed.destinationType === 'EP_DN') {
+      data.destinationType = CONSULT_TRANSFER_DESTINATION_TYPE.ENTRYPOINT;
+    } else {
+      // Keep the existing destinationType if it's something else (like "agent" or "Agent")
+      // Convert "Agent" to lowercase for consistency
+      data.destinationType = dataPassed.destinationType.toLowerCase();
+    }
+  } else {
+    data.destinationType = CONSULT_TRANSFER_DESTINATION_TYPE.AGENT;
+  }
+
+  return {
+    interactionId: interactionIdPassed,
+    data,
+  };
+};

package/src/services/core/aqm-reqs.ts

@@ -224,11 +224,6 @@ export default class AqmReqs {
     }
 
     if (event.keepalive === 'true') {
-      LoggerProxy.info(`Keepalive from web socket`, {
-        module: AQM_REQS_FILE,
-        method: METHODS.ON_MESSAGE,
-      });
-
       return;
     }
 

package/src/services/core/websocket/WebSocketManager.ts

@@ -178,10 +178,6 @@ export class WebSocketManager extends EventEmitter {
         issueReason = 'WebSocket auto close timed out. Forcefully closed websocket.';
       } else {
         const onlineStatus = navigator.onLine;
-        LoggerProxy.info(`[WebSocketStatus] | desktop online status is ${onlineStatus}`, {
-          module: WEB_SOCKET_MANAGER_FILE,
-          method: METHODS.WEB_SOCKET_ON_CLOSE_HANDLER,
-        });
         issueReason = !onlineStatus
           ? 'network issue'
           : 'missing keepalive from either desktop or notif service';

package/src/services/task/TaskManager.ts

@@ -28,6 +28,7 @@ export default class TaskManager extends EventEmitter {
   private metricsManager: MetricsManager;
   private static taskManager;
   private wrapupData: WrapupData;
+  private agentId: string;
   /**
    * @param contact - Routing Contact layer. Talks to AQMReq layer to convert events to promises
    * @param webCallingService - Webrtc Service Layer
@@ -52,6 +53,19 @@ export default class TaskManager extends EventEmitter {
     this.wrapupData = wrapupData;
   }
 
+  public setAgentId(agentId: string) {
+    this.agentId = agentId;
+  }
+
+  /**
+   * Gets the current agent ID
+   * @returns {string} The agent ID set for this task manager instance
+   * @public
+   */
+  public getAgentId(): string {
+    return this.agentId;
+  }
+
   private handleIncomingWebCall = (call: ICall) => {
     const currentTask = Object.values(this.taskCollection).find(
       (task) => task.data.interaction.mediaType === 'telephony'
@@ -117,7 +131,8 @@ export default class TaskManager extends EventEmitter {
                     payload.data.interaction?.participants?.[payload.data.agentId]?.isWrapUp ||
                     false,
                 },
-                this.wrapupData
+                this.wrapupData,
+                this.agentId
               );
               this.taskCollection[payload.data.interactionId] = task;
               // Condition 1: The state is=new i.e it is a incoming task
@@ -153,8 +168,9 @@ export default class TaskManager extends EventEmitter {
                 ...payload.data,
                 isConsulted: false,
               },
-              this.wrapupData
-            ); // Ensure isConsulted prop exists
+              this.wrapupData,
+              this.agentId
+            );
             this.taskCollection[payload.data.interactionId] = task;
             if (
               this.webCallingService.loginOption !== LoginOption.BROWSER ||
@@ -270,6 +286,7 @@ export default class TaskManager extends EventEmitter {
             break;
           case CC_EVENTS.AGENT_CONSULTING:
             // Received when agent is in an active consult state
+            // TODO: Check if we can use backend consult state instead of isConsulted
             task = this.updateTaskData(task, payload.data);
             if (task.data.isConsulted) {
               // Fire only if you are the agent who received the consult request
@@ -323,6 +340,65 @@ export default class TaskManager extends EventEmitter {
             task = this.updateTaskData(task, payload.data);
             task.emit(TASK_EVENTS.TASK_RECORDING_RESUME_FAILED, task);
             break;
+          case CC_EVENTS.AGENT_CONSULT_CONFERENCING:
+            // Conference is being established - update task state and emit establishing event
+            task = this.updateTaskData(task, payload.data);
+            task.emit(TASK_EVENTS.TASK_CONFERENCE_ESTABLISHING, task);
+            break;
+          case CC_EVENTS.AGENT_CONSULT_CONFERENCED:
+            // Conference started successfully - update task state and emit event
+            task = this.updateTaskData(task, payload.data);
+            task.emit(TASK_EVENTS.TASK_CONFERENCE_STARTED, task);
+            break;
+          case CC_EVENTS.AGENT_CONSULT_CONFERENCE_FAILED:
+            // Conference failed - update task state and emit failure event
+            task = this.updateTaskData(task, payload.data);
+            task.emit(TASK_EVENTS.TASK_CONFERENCE_FAILED, task);
+            break;
+          case CC_EVENTS.AGENT_CONSULT_CONFERENCE_ENDED:
+            // Conference ended - update task state and emit event
+            task = this.updateTaskData(task, payload.data);
+            task.emit(TASK_EVENTS.TASK_CONFERENCE_ENDED, task);
+            break;
+          case CC_EVENTS.PARTICIPANT_JOINED_CONFERENCE:
+            // Participant joined conference - update task state with participant information and emit event
+            task = this.updateTaskData(task, payload.data);
+            task.emit(TASK_EVENTS.TASK_PARTICIPANT_JOINED, task);
+            break;
+          case CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE:
+            // Conference ended - update task state and emit event
+            task = this.updateTaskData(task, payload.data);
+            task.emit(TASK_EVENTS.TASK_PARTICIPANT_LEFT, task);
+            break;
+          case CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE_FAILED:
+            // Conference exit failed - update task state and emit failure event
+            task = this.updateTaskData(task, payload.data);
+            task.emit(TASK_EVENTS.TASK_PARTICIPANT_LEFT_FAILED, task);
+            break;
+          case CC_EVENTS.AGENT_CONSULT_CONFERENCE_END_FAILED:
+            // Conference end failed - update task state with error details and emit failure event
+            task = this.updateTaskData(task, payload.data);
+            task.emit(TASK_EVENTS.TASK_CONFERENCE_END_FAILED, task);
+            break;
+          case CC_EVENTS.AGENT_CONFERENCE_TRANSFERRED:
+            // Conference was transferred - update task state and emit transfer success event
+            // Note: Backend should provide hasLeft and wrapUpRequired status
+            task = this.updateTaskData(task, payload.data);
+            task.emit(TASK_EVENTS.TASK_CONFERENCE_TRANSFERRED, task);
+            break;
+          case CC_EVENTS.AGENT_CONFERENCE_TRANSFER_FAILED:
+            // Conference transfer failed - update task state with error details and emit failure event
+            task = this.updateTaskData(task, payload.data);
+            task.emit(TASK_EVENTS.TASK_CONFERENCE_TRANSFER_FAILED, task);
+            break;
+          case CC_EVENTS.CONSULTED_PARTICIPANT_MOVING:
+            // Participant is being moved/transferred - update task state with movement info
+            task = this.updateTaskData(task, payload.data);
+            break;
+          case CC_EVENTS.PARTICIPANT_POST_CALL_ACTIVITY:
+            // Post-call activity for participant - update task state with activity details
+            task = this.updateTaskData(task, payload.data);
+            break;
           default:
             break;
         }

package/src/services/task/constants.ts

@@ -17,6 +17,9 @@ export const PAUSE = '/record/pause';
 export const RESUME = '/record/resume';
 export const WRAPUP = '/wrapup';
 export const END = '/end';
+export const CONSULT_CONFERENCE = '/consult/conference';
+export const CONFERENCE_EXIT = '/conference/exit';
+export const CONFERENCE_TRANSFER = '/conference/transfer';
 export const TASK_MANAGER_FILE = 'taskManager';
 export const TASK_FILE = 'task';
 
@@ -36,6 +39,9 @@ export const METHODS = {
   END_CONSULT: 'endConsult',
   TRANSFER: 'transfer',
   CONSULT_TRANSFER: 'consultTransfer',
+  CONSULT_CONFERENCE: 'consultConference',
+  EXIT_CONFERENCE: 'exitConference',
+  TRANSFER_CONFERENCE: 'transferConference',
   UPDATE_TASK_DATA: 'updateTaskData',
   RECONCILE_DATA: 'reconcileData',
 

package/src/services/task/contact.ts

@@ -17,6 +17,9 @@ import {
   TRANSFER,
   UNHOLD,
   WRAPUP,
+  CONSULT_CONFERENCE,
+  CONFERENCE_EXIT,
+  CONFERENCE_TRANSFER,
 } from './constants';
 import * as Contact from './types';
 import {DESTINATION_TYPE} from './types';
@@ -425,5 +428,82 @@ export default function routingContact(aqm: AqmReqs) {
         errId: 'Service.aqm.task.cancelCtq',
       },
     })),
+
+    /*
+     * Start consult conference
+     */
+    consultConference: aqm.req(
+      (p: {interactionId: string; data: Contact.ConsultConferenceData}) => ({
+        url: `${TASK_API}${p.interactionId}${CONSULT_CONFERENCE}`,
+        data: p.data,
+        host: WCC_API_GATEWAY,
+        err,
+        notifSuccess: {
+          bind: {
+            type: TASK_MESSAGE_TYPE,
+            data: {
+              type: [CC_EVENTS.AGENT_CONSULT_CONFERENCED, CC_EVENTS.AGENT_CONSULT_CONFERENCING],
+              interactionId: p.interactionId,
+            }, // any of the two events can be received for API success event
+          },
+          msg: {} as Contact.AgentContact,
+        },
+        notifFail: {
+          bind: {
+            type: TASK_MESSAGE_TYPE,
+            data: {type: CC_EVENTS.AGENT_CONSULT_CONFERENCE_FAILED},
+          },
+          errId: 'Service.aqm.task.consultConference',
+        },
+      })
+    ),
+
+    /*
+     * Exit conference
+     */
+    exitConference: aqm.req((p: {interactionId: string}) => ({
+      url: `${TASK_API}${p.interactionId}${CONFERENCE_EXIT}`,
+      data: {},
+      host: WCC_API_GATEWAY,
+      err,
+      notifSuccess: {
+        bind: {
+          type: TASK_MESSAGE_TYPE,
+          data: {type: CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE, interactionId: p.interactionId},
+        },
+        msg: {} as Contact.AgentContact,
+      },
+      notifFail: {
+        bind: {
+          type: TASK_MESSAGE_TYPE,
+          data: {type: CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE_FAILED}, // to be finalized
+        },
+        errId: 'Service.aqm.task.consultConference',
+      },
+    })),
+
+    /*
+     * Transfer conference
+     */
+    conferenceTransfer: aqm.req((p: {interactionId: string}) => ({
+      url: `${TASK_API}${p.interactionId}${CONFERENCE_TRANSFER}`,
+      data: {},
+      host: WCC_API_GATEWAY,
+      err,
+      notifSuccess: {
+        bind: {
+          type: TASK_MESSAGE_TYPE,
+          data: {type: CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE, interactionId: p.interactionId},
+        },
+        msg: {} as Contact.AgentContact,
+      },
+      notifFail: {
+        bind: {
+          type: TASK_MESSAGE_TYPE,
+          data: {type: CC_EVENTS.AGENT_CONFERENCE_TRANSFER_FAILED},
+        },
+        errId: 'Service.aqm.task.consultConference',
+      },
+    })),
   };
 }