@webex/contact-center 3.12.0-next.95 → 3.12.0-next.97

package/dist/webex.js

@@ -41,7 +41,7 @@ if (!global.Buffer) {
  */
 const Webex = _webexCore.default.extend({
   webex: true,
-  version: `3.12.0-next.95`
+  version: `3.12.0-next.97`
 });
 
 /**

package/package.json

@@ -45,7 +45,7 @@
   },
   "dependencies": {
     "@types/platform": "1.3.4",
-    "@webex/calling": "3.12.0-next.81",
+    "@webex/calling": "3.12.0-next.82",
     "@webex/internal-plugin-mercury": "3.12.0-next.40",
     "@webex/internal-plugin-metrics": "3.12.0-next.37",
     "@webex/internal-plugin-support": "3.12.0-next.41",
@@ -83,5 +83,5 @@
     "typedoc": "^0.25.0",
     "typescript": "5.4.5"
   },
-  "version": "3.12.0-next.95"
+  "version": "3.12.0-next.97"
 }

package/src/services/task/TaskUtils.ts

@@ -1,7 +1,13 @@
 /* eslint-disable import/prefer-default-export */
 import {Interaction, ITask, TaskData, MEDIA_CHANNEL} from './types';
 import {LoginOption} from '../../types';
-import {PARTICIPANT_TYPE, MEDIA_TYPE_MAIN_CALL} from './state-machine/constants';
+import {
+  PARTICIPANT_TYPE,
+  MEDIA_TYPE_MAIN_CALL,
+  CONSULT_STATE,
+  INTERACTION_STATE,
+  MEDIA_TYPE_CONSULT,
+} 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';
@@ -92,6 +98,25 @@ export const getIsConsultInProgressForConferenceControls = (
       const p: any = interaction.participants?.[participantId];
       if (!p || p.hasLeft) return false;
       if (selfAgentId && participantId === selfAgentId) return false;
+      if (mainSet.has(participantId)) return false;
+
+      const participantType = String(p.pType ?? '').toUpperCase();
+      const isEpDnParticipant =
+        participantType === 'EP-DN' || participantType === 'EP_DN' || participantType === 'DN';
+      if (isEpDnParticipant) {
+        if (!selfAgentId) {
+          return true;
+        }
+        const selfConsultState = interaction.participants?.[selfAgentId]?.consultState as
+          | string
+          | undefined;
+
+        return (
+          selfConsultState === 'consulting' ||
+          selfConsultState === 'conferencing' ||
+          selfConsultState === 'consultInitiated'
+        );
+      }
 
       const consultState = p.consultState as string | undefined;
       const isRonaPendingConsultee = consultState === 'consultReserved' && p.hasJoined === false;
@@ -100,7 +125,7 @@ export const getIsConsultInProgressForConferenceControls = (
         p.currentState === 'consulting' ||
         (p.isConsulted === true && consultState !== 'consultCompleted' && !isRonaPendingConsultee);
 
-      return consultLegActive && !mainSet.has(participantId);
+      return consultLegActive;
     });
   });
 };
@@ -216,6 +241,79 @@ export const getIsConferenceInProgress = (data: TaskData): boolean => {
   return agentParticipants.size >= 2;
 };
 
+const EP_DN_MERGE_TERMINAL_CONSULT_EVENTS = new Set<string>([
+  CC_EVENTS.AGENT_CONSULT_ENDED,
+  CC_EVENTS.AGENT_CONSULT_CONFERENCE_ENDED,
+]);
+
+const isEpDnParticipantType = (pType: string | undefined): boolean => {
+  const normalized = String(pType ?? '').toUpperCase();
+
+  return normalized === 'EP-DN' || normalized === 'EP_DN' || normalized === 'DN';
+};
+
+/** EP-DN consult merged to conference before a second agent joins the main leg (CAI-8329). */
+export const isEpDnConsultPendingConferenceMerge = (
+  taskData: TaskData | undefined,
+  selfAgentId: string | undefined
+): boolean => {
+  if (!taskData?.interaction || !selfAgentId) return false;
+
+  if (taskData.type && EP_DN_MERGE_TERMINAL_CONSULT_EVENTS.has(taskData.type)) {
+    return false;
+  }
+
+  const interaction = taskData.interaction;
+  const mainCallId = interaction.mainInteractionId || taskData.interactionId;
+  if (!mainCallId) return false;
+
+  if (getConferenceParticipantsCount(interaction, mainCallId) > 1) return false;
+
+  const selfParticipant = interaction.participants?.[selfAgentId] as
+    | {consultState?: string}
+    | undefined;
+  if (taskData.isConsulted === true || selfParticipant?.consultState === 'consultCompleted') {
+    return false;
+  }
+
+  const mainParticipantIds = new Set(interaction.media?.[mainCallId]?.participants ?? []);
+  const hasEpDnOnConsultLegNotMain = Object.values(interaction.media ?? {}).some((media: any) => {
+    if (media?.mType !== MEDIA_TYPE_CONSULT) return false;
+
+    return (media.participants ?? []).some((participantId: string) => {
+      if (participantId === selfAgentId || mainParticipantIds.has(participantId)) return false;
+      const participant = interaction.participants?.[participantId] as
+        | {hasLeft?: boolean; pType?: string}
+        | undefined;
+      if (!participant || participant.hasLeft) return false;
+
+      return isEpDnParticipantType(participant.pType);
+    });
+  });
+  if (!hasEpDnOnConsultLegNotMain) return false;
+
+  const callProcessingDetails = interaction.callProcessingDetails as
+    | {hasCustomerLeft?: string}
+    | undefined;
+  const customerLeft =
+    callProcessingDetails?.hasCustomerLeft === 'true' ||
+    !getIsCustomerInCall(interaction, mainCallId);
+
+  const conferenceFromPayload =
+    interaction.state === INTERACTION_STATE.CONFERENCE ||
+    getIsConferenceInProgress(taskData) ||
+    (interaction.state === INTERACTION_STATE.POST_CALL && customerLeft);
+  if (!conferenceFromPayload) return false;
+
+  return (
+    taskData.consultingAgentId === selfAgentId ||
+    interaction.owner === selfAgentId ||
+    selfParticipant?.consultState === CONSULT_STATE.CONSULTING ||
+    selfParticipant?.consultState === CONSULT_STATE.CONFERENCING ||
+    selfParticipant?.consultState === 'consultInitiated'
+  );
+};
+
 /**
  * Checks if the current agent is a secondary agent in a consultation scenario.
  * Secondary agents are those who were consulted (not the original call owner).

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

@@ -101,6 +101,11 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
               target: TaskState.WRAPPING_UP,
               actions: ['updateTaskData', 'markEnded', 'emitTaskHydrate'],
             },
+            {
+              guard: guards.isEpDnPendingConferenceMergeHydrate,
+              target: TaskState.CONFERENCING,
+              actions: ['updateTaskData', 'emitTaskHydrate'],
+            },
             {
               guard: guards.isInteractionConsulting,
               target: TaskState.CONSULTING,
@@ -299,6 +304,14 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
             target: TaskState.HELD,
             actions: ['updateTaskData', 'setHoldState', 'emitTaskHold'],
           },
+          [TaskEvent.UNHOLD_INITIATED]: {
+            target: TaskState.RESUME_INITIATING,
+          },
+          // Resume while machine is CONNECTED but main media is still on hold (stale state after consult RONA/decline).
+          [TaskEvent.UNHOLD_SUCCESS]: {
+            target: TaskState.CONNECTED,
+            actions: ['updateTaskData', 'setHoldState', 'emitTaskResume'],
+          },
           // Click of the consult button
           [TaskEvent.CONSULT]: {
             target: TaskState.CONSULT_INITIATING,
@@ -691,6 +704,48 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
             actions: ['updateTaskData', 'setHoldState', 'emitTaskResume'],
           },
 
+          [TaskEvent.PARTICIPANT_LEAVE]: [
+            {
+              guard: (params) =>
+                guards.didCurrentAgentLeaveConference(params) && guards.shouldWrapUp(params),
+              target: TaskState.WRAPPING_UP,
+              actions: [
+                'updateTaskData',
+                'handleParticipantLeft',
+                'markEnded',
+                'clearConsultState',
+                'emitTaskParticipantLeft',
+                'emitTaskWrapup',
+              ],
+            },
+            {
+              guard: guards.didCurrentAgentLeaveConference,
+              target: TaskState.TERMINATED,
+              actions: [
+                'updateTaskData',
+                'handleParticipantLeft',
+                'markEnded',
+                'clearConsultState',
+                'emitTaskParticipantLeft',
+                'emitTaskEnd',
+              ],
+            },
+            {
+              guard: (params) =>
+                !guards.didCurrentAgentLeaveConference(params) &&
+                guards.shouldDowngradeConferenceToConnected(params),
+              target: TaskState.CONNECTED,
+              actions: [
+                'updateTaskData',
+                'handleParticipantLeft',
+                'clearConsultState',
+                'emitTaskParticipantLeft',
+                'emitTaskConferenceEnded',
+              ],
+            },
+            {actions: ['updateTaskData', 'handleParticipantLeft', 'emitTaskParticipantLeft']},
+          ],
+
           [TaskEvent.TRANSFER_SUCCESS]: [
             {
               guard: guards.shouldWrapUpOrIsInitiator,
@@ -711,14 +766,6 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
             actions: ['setTransferConferenceRequested', 'emitTaskTransferConference'],
           },
           [TaskEvent.TRANSFER_CONFERENCE_SUCCESS]: [
-            {
-              guard: ({context}) => context.transferConferenceRequested !== true,
-              actions: [
-                'updateTaskData',
-                'handleTransferConferenceSuccess',
-                'clearTransferConferenceRequested',
-              ],
-            },
             {
               guard: guards.shouldWrapUp,
               target: TaskState.WRAPPING_UP,
@@ -732,8 +779,8 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
               ],
             },
             {
-              // Non-initiator (consulted agent) stays in CONFERENCING
-              guard: ({context}) => !context.consultInitiator,
+              // Non-initiator (e.g. consultee receiving transfer) moves to CONFERENCING
+              guard: (params) => !guards.isSelfConferenceTransferInitiator(params),
               target: TaskState.CONFERENCING,
               actions: [
                 'updateTaskData',
@@ -977,14 +1024,46 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
           },
           [TaskEvent.TRANSFER_CONFERENCE_SUCCESS]: [
             {
-              // Not initiated by this agent → just refresh backend state.
-              guard: ({context}) => context.transferConferenceRequested !== true,
+              guard: guards.isPassiveConferenceTransferObserver,
+              actions: [
+                'updateTaskData',
+                'handleTransferConferenceSuccess',
+                'clearTransferConferenceRequested',
+              ],
+            },
+            {
+              guard: guards.shouldWrapUp,
+              target: TaskState.WRAPPING_UP,
+              actions: [
+                'updateTaskData',
+                'markEnded',
+                'clearConsultState',
+                'handleTransferConferenceSuccess',
+                'clearTransferConferenceRequested',
+                'emitTaskWrapup',
+              ],
+            },
+            {
+              guard: (params) => !guards.isSelfConferenceTransferInitiator(params),
+              target: TaskState.CONFERENCING,
               actions: [
                 'updateTaskData',
+                'clearConsultState',
                 'handleTransferConferenceSuccess',
                 'clearTransferConferenceRequested',
               ],
             },
+            {
+              target: TaskState.TERMINATED,
+              actions: [
+                'updateTaskData',
+                'markEnded',
+                'clearConsultState',
+                'handleTransferConferenceSuccess',
+                'clearTransferConferenceRequested',
+                'emitTaskEnd',
+              ],
+            },
           ],
           [TaskEvent.TRANSFER_CONFERENCE_FAILED]: {
             actions: ['clearTransferConferenceRequested', 'emitTaskTransferConferenceFailed'],
@@ -1026,6 +1105,16 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
               actions: ['updateTaskData', 'requestCleanup'],
             },
           ],
+
+          [TaskEvent.CONSULT_FAILED]: {
+            actions: ['updateTaskData', 'handleConsultFailed'],
+          },
+
+          [TaskEvent.TASK_WRAPUP]: {
+            guard: guards.shouldWrapUp,
+            target: TaskState.WRAPPING_UP,
+            actions: ['updateTaskData', 'markEnded', 'clearConsultState', 'emitTaskWrapup'],
+          },
         },
       },
 

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

@@ -19,10 +19,17 @@ import {
   MEDIA_TYPE_CONSULT,
 } from './constants';
 import {DestinationType, TaskData} from '../types';
+import {CC_EVENTS} from '../../config/types';
 import {computeUIControls, getDefaultUIControls} from './uiControlsComputer';
-import {getIsConferenceInProgress} from '../TaskUtils';
+import {getIsConferenceInProgress, isEpDnConsultPendingConferenceMerge} from '../TaskUtils';
 import {hasActiveConsultInPostCall} from './guards';
 
+/** Terminal consult events that clear consult context in deriveTaskDataUpdates. */
+const CONSULT_CONTEXT_CLEAR_EVENTS = new Set<string>([
+  CC_EVENTS.AGENT_CONSULT_ENDED,
+  CC_EVENTS.AGENT_CONSULT_FAILED,
+]);
+
 const determineConsultInitiator = (
   taskData: TaskData | undefined,
   selfAgentId: string | undefined
@@ -98,7 +105,8 @@ const isActiveConsultState = (taskData: TaskData | undefined, selfAgentId?: stri
       return false;
     }
     if (
-      selfParticipant?.consultState === CONSULT_STATE.CONSULTING &&
+      (selfParticipant?.consultState === CONSULT_STATE.CONSULTING ||
+        selfParticipant?.consultState === CONSULT_STATE.CONFERENCING) &&
       hasConsultMedia &&
       taskData?.isConsulted === false
     ) {
@@ -125,6 +133,7 @@ const isSelfConsultingOrPending = (
 
   return (
     selfParticipant?.consultState === CONSULT_STATE.CONSULTING ||
+    selfParticipant?.consultState === CONSULT_STATE.CONFERENCING ||
     selfParticipant?.consultState === 'consultInitiated'
   );
 };
@@ -225,6 +234,11 @@ export const getTaskStateForUiControls = (
     return TaskState.WRAPPING_UP;
   }
 
+  // EP-DN consult merged to conference before Agent 2 joins main — UI is conferencing (CAI-8329).
+  if (isEpDnConsultPendingConferenceMerge(taskData, selfAgentId)) {
+    return TaskState.CONFERENCING;
+  }
+
   if (isActiveConsultState(taskData, selfAgentId)) {
     return TaskState.CONSULTING;
   }
@@ -250,34 +264,43 @@ export const getTaskStateForUiControls = (
 const deriveTaskDataUpdates = (context: TaskContext, taskData: TaskData | undefined) =>
   taskData
     ? (() => {
+        const enrichedTaskData: TaskData =
+          taskData.type === 'AgentConsultCreated' && taskData.agentId
+            ? {...taskData, consultingAgentId: taskData.agentId}
+            : taskData;
+
         const updates: Partial<TaskContext> = {
-          taskData,
-          ...deriveRecordingState(taskData),
+          taskData: enrichedTaskData,
+          ...deriveRecordingState(enrichedTaskData),
         };
 
-        const selfAgentId = context.uiControlConfig.agentId ?? taskData?.agentId;
+        const selfAgentId = context.uiControlConfig.agentId ?? enrichedTaskData?.agentId;
         const consultingActive =
-          isActiveConsultState(taskData, selfAgentId) ||
-          hasActiveConsultInPostCall(taskData, selfAgentId);
+          isActiveConsultState(enrichedTaskData, selfAgentId) ||
+          hasActiveConsultInPostCall(enrichedTaskData, selfAgentId);
         const conferenceFromPayload =
-          taskData?.interaction?.state === INTERACTION_STATE.CONFERENCE ||
-          getIsConferenceInProgress(taskData);
-        const selfConsultingOrPending = isSelfConsultingOrPending(taskData, selfAgentId);
+          enrichedTaskData?.interaction?.state === INTERACTION_STATE.CONFERENCE ||
+          getIsConferenceInProgress(enrichedTaskData);
+        const selfConsultingOrPending = isSelfConsultingOrPending(enrichedTaskData, selfAgentId);
         const inferredConsultingInitiator =
-          selfConsultingOrPending && taskData?.isConsulted === false;
+          selfConsultingOrPending && enrichedTaskData?.isConsulted === false;
 
-        if (taskData.destAgentId) {
+        if (enrichedTaskData.destAgentId) {
           const isEpDnWithStoredId =
             context.consultDestinationType === 'entryPoint' && context.consultDestinationAgentId;
           if (!isEpDnWithStoredId) {
-            updates.consultDestinationAgentId = taskData.destAgentId;
+            updates.consultDestinationAgentId = enrichedTaskData.destAgentId;
           }
         }
 
         const isConsultTerminalEvent =
-          taskData.type === 'AgentConsultEnded' || taskData.type === 'AgentConsultFailed';
+          enrichedTaskData.type != null && CONSULT_CONTEXT_CLEAR_EVENTS.has(enrichedTaskData.type);
+        const epDnPendingMergeActive = isEpDnConsultPendingConferenceMerge(
+          enrichedTaskData,
+          selfAgentId
+        );
 
-        if (isConsultTerminalEvent) {
+        if (isConsultTerminalEvent && !epDnPendingMergeActive) {
           updates.consultInitiator = false;
           updates.consultFromConference = false;
           updates.consultDestinationAgentJoined = false;
@@ -285,21 +308,38 @@ const deriveTaskDataUpdates = (context: TaskContext, taskData: TaskData | undefi
           updates.consultDestinationType = null;
           updates.consultDestinationAgentId = null;
           updates.transferConferenceRequested = false;
+          updates.hideBlindTransferForEpDnPendingMerge = false;
         }
 
-        if (consultingActive && taskData.destinationType) {
-          updates.consultDestinationType = mapConsultDestinationType(taskData.destinationType);
+        updates.hideBlindTransferForEpDnPendingMerge = isEpDnConsultPendingConferenceMerge(
+          enrichedTaskData,
+          selfAgentId
+        );
+
+        if (consultingActive && enrichedTaskData.destinationType) {
+          updates.consultDestinationType = mapConsultDestinationType(
+            enrichedTaskData.destinationType
+          );
         }
 
-        if (!isConsultTerminalEvent && !context.consultInitiator) {
-          const consultInitiator = determineConsultInitiator(taskData, selfAgentId);
+        if (!isConsultTerminalEvent) {
+          const consultInitiator = determineConsultInitiator(enrichedTaskData, selfAgentId);
           if (consultInitiator !== undefined) {
             updates.consultInitiator = consultInitiator;
           } else if (
-            inferredConsultingInitiator ||
-            (consultingActive && taskData.isConsulted === false)
+            enrichedTaskData.type === 'AgentConsultCreated' &&
+            enrichedTaskData.agentId &&
+            enrichedTaskData.agentId !== selfAgentId &&
+            conferenceFromPayload
           ) {
-            updates.consultInitiator = true;
+            updates.consultInitiator = false;
+          } else if (!context.consultInitiator) {
+            if (
+              inferredConsultingInitiator ||
+              (consultingActive && enrichedTaskData.isConsulted === false)
+            ) {
+              updates.consultInitiator = true;
+            }
           }
         }
 
@@ -308,7 +348,9 @@ const deriveTaskDataUpdates = (context: TaskContext, taskData: TaskData | undefi
           !isConsultTerminalEvent &&
           effectiveConsultInitiator &&
           conferenceFromPayload &&
-          (consultingActive || selfConsultingOrPending || Boolean(taskData?.consultMediaResourceId))
+          (consultingActive ||
+            selfConsultingOrPending ||
+            Boolean(enrichedTaskData?.consultMediaResourceId))
         ) {
           updates.consultFromConference = true;
         }
@@ -316,16 +358,16 @@ const deriveTaskDataUpdates = (context: TaskContext, taskData: TaskData | undefi
         if (
           !isConsultTerminalEvent &&
           (consultingActive || selfConsultingOrPending) &&
-          taskData.interaction
+          enrichedTaskData.interaction
         ) {
-          const joinedConsultee = hasJoinedConsultDestination(taskData, selfAgentId);
+          const joinedConsultee = hasJoinedConsultDestination(enrichedTaskData, selfAgentId);
           const selfParticipant = selfAgentId
-            ? (taskData.interaction.participants?.[selfAgentId] as
+            ? (enrichedTaskData.interaction.participants?.[selfAgentId] as
                 | {consultState?: string}
                 | undefined)
             : undefined;
           const agentConsultingSelfJoined =
-            taskData.type === 'AgentConsulting' &&
+            enrichedTaskData.type === 'AgentConsulting' &&
             effectiveConsultInitiator &&
             selfParticipant?.consultState === CONSULT_STATE.CONSULTING;
 
@@ -337,8 +379,8 @@ const deriveTaskDataUpdates = (context: TaskContext, taskData: TaskData | undefi
 
           if (!context.consultDestinationType && !updates.consultDestinationType) {
             const hasEpDnParticipant = Boolean(
-              taskData.interaction.participants &&
-                Object.values(taskData.interaction.participants).some((p: any) => {
+              enrichedTaskData.interaction.participants &&
+                Object.values(enrichedTaskData.interaction.participants).some((p: any) => {
                   if (p?.hasLeft) return false;
                   const pType = String(p?.pType ?? '').toUpperCase();
 
@@ -349,7 +391,7 @@ const deriveTaskDataUpdates = (context: TaskContext, taskData: TaskData | undefi
           }
 
           if (effectiveConsultInitiator) {
-            const consultCallHeld = deriveConsultCallHeldFromTaskData(taskData);
+            const consultCallHeld = deriveConsultCallHeldFromTaskData(enrichedTaskData);
             if (consultCallHeld !== undefined) {
               updates.consultCallHeld = consultCallHeld;
             }
@@ -360,9 +402,9 @@ const deriveTaskDataUpdates = (context: TaskContext, taskData: TaskData | undefi
           ...context,
           ...updates,
         } as TaskContext;
-        const inferredState = getTaskStateForUiControls(taskData, selfAgentId);
+        const inferredState = getTaskStateForUiControls(enrichedTaskData, selfAgentId);
 
-        updates.uiControls = computeUIControls(inferredState, nextContext, taskData);
+        updates.uiControls = computeUIControls(inferredState, nextContext, enrichedTaskData);
 
         return updates;
       })()
@@ -385,6 +427,7 @@ export function createInitialContext(
     consultDestinationAgentId: null,
     consultDestinationAgentJoined: false,
     consultCallHeld: false,
+    hideBlindTransferForEpDnPendingMerge: false,
     recordingControlsAvailable: false,
     recordingInProgress: false,
     uiControlConfig,
@@ -446,6 +489,11 @@ export const actions: TaskActionsMap = {
 
   handleConsultFailed: assign(({context, event}: TaskActionArgs) => {
     const taskData = getTaskDataFromEvent(event) ?? context.taskData;
+    const selfAgentId = context.uiControlConfig.agentId ?? taskData?.agentId;
+    const hideBlindTransferForEpDnPendingMerge = isEpDnConsultPendingConferenceMerge(
+      taskData,
+      selfAgentId
+    );
     const cleared = {
       consultDestinationType: null,
       consultDestinationAgentId: null,
@@ -455,8 +503,8 @@ export const actions: TaskActionsMap = {
       consultCallHeld: false,
       consultFromConference: false,
       transferConferenceRequested: false,
+      hideBlindTransferForEpDnPendingMerge,
     };
-    const selfAgentId = context.uiControlConfig.agentId ?? taskData?.agentId;
     const nextContext = {...context, ...cleared, taskData} as TaskContext;
     const inferredState = getTaskStateForUiControls(taskData, selfAgentId);
 
@@ -539,6 +587,12 @@ export const actions: TaskActionsMap = {
   }),
 
   clearConsultState: assign(({context, event}: TaskActionArgs) => {
+    const taskData = context.taskData ?? getTaskDataFromEvent(event);
+    const selfAgentId = context.uiControlConfig.agentId ?? taskData?.agentId;
+    const hideBlindTransferForEpDnPendingMerge = isEpDnConsultPendingConferenceMerge(
+      taskData,
+      selfAgentId
+    );
     const cleared = {
       consultDestinationType: null,
       consultDestinationAgentId: null,
@@ -548,9 +602,8 @@ export const actions: TaskActionsMap = {
       consultCallHeld: false,
       consultFromConference: false,
       transferConferenceRequested: false,
+      hideBlindTransferForEpDnPendingMerge,
     };
-    const taskData = context.taskData ?? getTaskDataFromEvent(event);
-    const selfAgentId = context.uiControlConfig.agentId ?? taskData?.agentId;
     const nextContext = {...context, ...cleared, taskData} as TaskContext;
     const inferredState = getTaskStateForUiControls(taskData, selfAgentId);