@webex/contact-center 3.12.0-task-refactor.4 → 3.12.0-task-refactor.6

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

@@ -144,16 +144,27 @@ function computeVoiceInteractionUIControls(
     Boolean(selfAgentId) &&
     Boolean(mainCallId) &&
     Boolean(interaction?.media?.[mainCallId]?.participants?.includes(selfAgentId as string));
+  const consultMedia = Object.values(interaction?.media ?? {}).find(
+    (media: any) =>
+      media?.mediaResourceId === taskData?.consultMediaResourceId || media?.mType === 'consult'
+  ) as {participants?: string[]} | undefined;
+  const selfParticipant = selfAgentId ? interaction?.participants?.[selfAgentId] : null;
+  const selfInConsultCall =
+    Boolean(selfAgentId) && Boolean(consultMedia?.participants?.includes(selfAgentId as string));
   const conferenceActive = isConferencing || conferenceFromBackend || consultFromConference;
   // Treat consult initiator as "in conference" even if mainCall participant list lags while consulting.
   const inConference = conferenceActive && (isConferencing || selfInMainCall || consultInitiator);
 
   // Check if this is a consulted agent (must be after isConsulting is computed).
-  const isSoleAgentOnCall = participantCount <= 1 && !isConsulting && !inConference;
+  const isSoleAgentOnCall =
+    participantCount <= 1 && selfInMainCall && !isConsulting && !inConference;
   const isConsulted =
     inConference || isSoleAgentOnCall
       ? false
-      : getIsConsultedAgentForControls(taskData, context, isConsulting);
+      : getIsConsultedAgentForControls(taskData, context, isConsulting) ||
+        (!consultInitiator &&
+          (selfParticipant?.isConsulted === true ||
+            selfParticipant?.consultState === 'consulting'));
 
   // Active call = can perform call operations
   const isActive =
@@ -173,29 +184,111 @@ function computeVoiceInteractionUIControls(
     taskData?.consultMediaResourceId ||
       Object.values(interaction?.media ?? {}).some((media: any) => media?.mType === 'consult')
   );
+  const selfConsultPendingOnConsultMedia =
+    selfParticipant?.consultState === 'consultInitiated' &&
+    !taskData?.isConsulted &&
+    hasConsultMedia;
+  const ownerParticipant = interaction?.owner
+    ? interaction.participants?.[interaction.owner]
+    : undefined;
+  const otherAgentConsultInProgress = Boolean(
+    interaction?.participants &&
+      Object.values(interaction.participants).some((participant: any) => {
+        if (!participant || participant.hasLeft) return false;
+        if (participant.id === selfAgentId) return false;
+        if (participant.pType !== 'AGENT') return false;
+
+        return (
+          participant.consultState === 'consultInitiated' ||
+          participant.consultState === 'consultReserved' ||
+          participant.consultState === 'consulting' ||
+          participant.currentState === 'consulting'
+        );
+      })
+  );
+  const isHydratedConferenceConsultPending =
+    inConference && selfConsultPendingOnConsultMedia && !consultDestinationAgentJoined;
   const hasParallelConsultLeg =
     consultOwnedBySelf &&
     !isConsulting &&
     !isConsulted &&
     (consultInProgress || consultCallHeld || hasConsultMedia);
+  const activeLegForConferenceConsult = consultCallHeld ? 'main' : 'consult';
+  const isCurrentLegActive = currentLeg === activeLegForConferenceConsult;
+  const isConferenceConsultTransferContext =
+    inConference && consultInitiator && hasConsultMedia && isConsultDestinationReady;
   const consultLegOnHold = isConsulting && consultCallHeld;
+  const callProcessingDetails = interaction?.callProcessingDetails as
+    | {conferenceHoldParticipant?: boolean | string}
+    | undefined;
+  const conferenceHoldParticipant =
+    callProcessingDetails?.conferenceHoldParticipant === true ||
+    callProcessingDetails?.conferenceHoldParticipant === 'true';
+  const postDeclineHeldMainLeg =
+    consultInitiator &&
+    !consultDestinationAgentJoined &&
+    isHeld &&
+    inConference &&
+    conferenceHoldParticipant;
+  const postConsultCompletedHeldMainLeg =
+    selfParticipant?.consultState === 'consultCompleted' && isHeld && inConference && !isConsulting;
+  const nonOwnerPostConsultCompletedHeldMainLeg =
+    isHeld &&
+    inConference &&
+    !isConsulting &&
+    !consultInitiator &&
+    Boolean(selfAgentId) &&
+    Boolean(interaction?.owner) &&
+    selfAgentId !== interaction?.owner &&
+    ownerParticipant?.consultState === 'consultCompleted';
+  const isConsultPendingBeforeJoin =
+    selfParticipant?.consultState === 'consultInitiated' && !consultDestinationAgentJoined;
+  const hideExitConferenceWhileConsultPending =
+    currentLeg === 'main' &&
+    inConference &&
+    isConsultPendingBeforeJoin &&
+    (consultFromConference ||
+      consultInitiator ||
+      taskData?.type === 'AgentConsultCreated' ||
+      consultInProgress ||
+      isConsulting);
+  const hideExitConferenceDuringActiveConsultFromConference =
+    inConference &&
+    consultInitiator &&
+    consultDestinationAgentJoined &&
+    (isConsulting ||
+      taskData?.type === 'AgentConsulting' ||
+      selfParticipant?.consultState === 'consulting');
+  const forceHeldPostConsultControls =
+    !hideExitConferenceWhileConsultPending &&
+    (postDeclineHeldMainLeg || postConsultCompletedHeldMainLeg);
+  const selfOnConsultLeg =
+    selfParticipant?.consultState === 'consulting' ||
+    selfParticipant?.currentState === 'consulting';
+  const showMainLegConferenceControlsDuringConsult =
+    currentLeg === 'main' && inConference && consultInProgress && !selfOnConsultLeg;
+  const allowHeldMainLegControlsForNonInitiator =
+    showMainLegConferenceControlsDuringConsult && !isHydratedConferenceConsultPending;
 
   return {
     // Accept/Decline: Voice tasks in offered state
-    // For outdial, accept is disabled (auto-answer handles it), decline remains enabled
-    // For Extension mode (non-WebRTC), accept shows as disabled "Ringing" button
+    // Desktop/WebRTC + inbound: accept enabled (agent manually accepts)
+    // Desktop/WebRTC + outdial: accept disabled (auto-answer handles it; Widgets show "Accept" disabled)
+    // Extension mode (non-WebRTC): accept disabled (Widgets show "Ringing...")
     accept:
       state === TaskState.OFFERED && !interaction?.isTerminated
         ? {isVisible: true, isEnabled: isWebrtc && !isOutdial}
         : DISABLED,
-    decline:
-      isWebrtc && state === TaskState.OFFERED && !interaction?.isTerminated
-        ? VISIBLE_ENABLED
-        : DISABLED,
+    decline: (() => {
+      if (!isWebrtc || state !== TaskState.OFFERED || interaction?.isTerminated) return DISABLED;
+
+      return isOutdial ? VISIBLE_DISABLED : VISIBLE_ENABLED;
+    })(),
 
     // Hold: visible in connected/held/conference, disabled in conference/consulting
     hold: (() => {
       if (!hasFullControls) return DISABLED;
+      if (forceHeldPostConsultControls) return VISIBLE_ENABLED;
       if (consultOwnedBySelf && (isConsulting || hasParallelConsultLeg || consultCallHeld)) {
         return DISABLED;
       }
@@ -214,6 +307,7 @@ function computeVoiceInteractionUIControls(
     mute: (() => {
       if (!isWebrtc) return DISABLED;
       if (isWrappingUp) return DISABLED;
+      if (currentLeg === 'consult' && !selfInConsultCall) return DISABLED;
       if (isConsulting) return VISIBLE_ENABLED;
 
       if (isConnected || isHeld || isConferencing) {
@@ -227,6 +321,9 @@ function computeVoiceInteractionUIControls(
 
     // End: varies by state; during consulting only on main leg (consult held)
     end: (() => {
+      if (allowHeldMainLegControlsForNonInitiator) return VISIBLE_ENABLED;
+      if (showMainLegConferenceControlsDuringConsult) return VISIBLE_DISABLED;
+      if (isHydratedConferenceConsultPending && currentLeg === 'main') return VISIBLE_DISABLED;
       if (!config.isEndTaskEnabled) return DISABLED;
       if (hasParallelConsultLeg) {
         return isConnected && isEpDnConsult ? VISIBLE_ENABLED : VISIBLE_DISABLED;
@@ -240,6 +337,7 @@ function computeVoiceInteractionUIControls(
 
       if (inConference) {
         if (isConsulted) return DISABLED;
+        if (forceHeldPostConsultControls) return VISIBLE_DISABLED;
 
         if (consultInProgress) return VISIBLE_DISABLED;
 
@@ -253,6 +351,11 @@ function computeVoiceInteractionUIControls(
 
     // Transfer: connected/held/conference
     transfer: (() => {
+      if (isHydratedConferenceConsultPending) return VISIBLE_DISABLED;
+      if (isConferenceConsultTransferContext && currentLeg === 'main' && isCurrentLegActive) {
+        return DISABLED;
+      }
+      if (inConference && isConsulting && consultInitiator) return DISABLED;
       if (hasParallelConsultLeg) {
         if (!customerPresent) return DISABLED;
         if (state === TaskState.CONNECTED) return VISIBLE_ENABLED;
@@ -280,6 +383,7 @@ function computeVoiceInteractionUIControls(
     consult: (() => {
       const isConnectedOrHeld = state === TaskState.CONNECTED || state === TaskState.HELD;
 
+      if (inConference && nonOwnerPostConsultCompletedHeldMainLeg) return VISIBLE_DISABLED;
       if (hasParallelConsultLeg) return DISABLED;
       if (!hasFullControls || !(isConnectedOrHeld || inConference)) {
         return DISABLED;
@@ -291,7 +395,11 @@ function computeVoiceInteractionUIControls(
         if (participantCount <= 1) return VISIBLE_DISABLED;
         // Real conference: consult enabled if conditions met
         const canFromConference =
-          !maxParticipants && customerPresent && !consultInProgress && !isConsulting;
+          !maxParticipants &&
+          customerPresent &&
+          !consultInProgress &&
+          !otherAgentConsultInProgress &&
+          !isConsulting;
 
         return {isVisible: true, isEnabled: canFromConference};
       }
@@ -337,6 +445,7 @@ function computeVoiceInteractionUIControls(
     // Conference: during consulting, enabled on both legs when agent joined
     // Label changes based on leg: "Conference" on main leg, "Merge" on consult leg
     conference: (() => {
+      if (isHydratedConferenceConsultPending && currentLeg === 'main') return VISIBLE_DISABLED;
       if (hasParallelConsultLeg) {
         if (!customerPresent) return DISABLED;
         if (state === TaskState.CONNECTED) {
@@ -359,9 +468,15 @@ function computeVoiceInteractionUIControls(
 
     // ExitConference: in conference with multiple agents in main call
     exitConference: (() => {
+      if (hideExitConferenceWhileConsultPending) return DISABLED;
+      if (allowHeldMainLegControlsForNonInitiator) return VISIBLE_ENABLED;
+      if (showMainLegConferenceControlsDuringConsult) return VISIBLE_DISABLED;
+      if (hideExitConferenceDuringActiveConsultFromConference) return DISABLED;
+      if (forceHeldPostConsultControls) return VISIBLE_DISABLED;
       if (isConsulted && !isConferencing) return DISABLED;
       if (!inConference) return DISABLED;
       if (participantCount <= 1) return DISABLED;
+      if (consultInProgress) return VISIBLE_DISABLED;
       const consultingFromConference = consultInitiator && isConsulting && conferenceFromBackend;
 
       return consultingFromConference ? VISIBLE_DISABLED : VISIBLE_ENABLED;
@@ -369,8 +484,19 @@ function computeVoiceInteractionUIControls(
 
     // TransferConference: in conference with active consult, owner consulting from conference
     transferConference: (() => {
-      if (hasParallelConsultLeg || consultLegOnHold) return DISABLED;
-      if (!inConference || !isConsulting) return DISABLED;
+      if (isConferenceConsultTransferContext && !isCurrentLegActive) return VISIBLE_DISABLED;
+      const consultLegTransferAvailable =
+        currentLeg === 'consult' && inConference && consultInitiator && hasConsultMedia;
+      const selfConsultingOnParticipantState = selfParticipant?.consultState === 'consulting';
+      const conferenceTransferAvailable =
+        consultLegTransferAvailable ||
+        (inConference &&
+          consultInitiator &&
+          hasConsultMedia &&
+          (isConsulting || consultInProgress || selfConsultingOnParticipantState));
+      if (consultLegOnHold) return DISABLED;
+      if (hasParallelConsultLeg && !conferenceTransferAvailable) return DISABLED;
+      if (!conferenceTransferAvailable && (!inConference || !isConsulting)) return DISABLED;
       if (!consultInitiator || isConsulted) return DISABLED;
 
       return isConsultDestinationReady ? VISIBLE_ENABLED : VISIBLE_DISABLED;
@@ -378,6 +504,7 @@ function computeVoiceInteractionUIControls(
 
     // MergeToConference: mirrors conference control, enabled on both legs
     mergeToConference: (() => {
+      if (isHydratedConferenceConsultPending && currentLeg === 'consult') return VISIBLE_DISABLED;
       if (!isConsulting || !consultInitiator) return DISABLED;
       if (!customerPresent) return VISIBLE_DISABLED;
       if (consultLegOnHold) return VISIBLE_DISABLED;
@@ -387,6 +514,7 @@ function computeVoiceInteractionUIControls(
 
     // Switch: visible only on the currently active leg
     switch: (() => {
+      if (isHydratedConferenceConsultPending && currentLeg === 'consult') return VISIBLE_DISABLED;
       if (!customerPresent && hasParallelConsultLeg) return DISABLED;
       if (currentLeg === 'consult') {
         if (!isConsulting || !consultInitiator || consultCallHeld) return DISABLED;
@@ -470,10 +598,18 @@ function getVoiceLegState(
     taskData?.consultMediaResourceId ||
       Object.values(interaction?.media ?? {}).some((media: any) => media?.mType === 'consult')
   );
+  const selfParticipant = selfAgentId ? interaction?.participants?.[selfAgentId] : null;
+  const selfConsultPendingOnConsultMedia =
+    selfParticipant?.consultState === 'consultInitiated' &&
+    !taskData?.isConsulted &&
+    hasConsultMedia;
+  const selfConsultingOnConsultMedia =
+    selfParticipant?.consultState === 'consulting' && hasConsultMedia;
   const hasConsultLeg = Boolean(
-    consultOwnedBySelf &&
-      !taskData?.isConsulted &&
-      !interaction?.isTerminated &&
+    !interaction?.isTerminated &&
+      ((consultOwnedBySelf && !taskData?.isConsulted) ||
+        selfConsultingOnConsultMedia ||
+        selfConsultPendingOnConsultMedia) &&
       (consultInProgress || isConsultingState || context.consultCallHeld || hasConsultMedia)
   );
 
@@ -486,10 +622,17 @@ function getVoiceLegState(
     };
   }
 
+  let mainState = TaskState.HELD;
+  if (currentState === TaskState.CONFERENCING) {
+    mainState = TaskState.CONFERENCING;
+  } else if (context.consultCallHeld) {
+    mainState = TaskState.CONNECTED;
+  }
+
   return {
     hasConsultLeg: true,
     activeLeg: context.consultCallHeld ? 'main' : 'consult',
-    mainState: context.consultCallHeld ? TaskState.CONNECTED : TaskState.HELD,
+    mainState,
     consultState: isConsultingState ? currentState : TaskState.CONSULTING,
   };
 }

package/src/services/task/voice/Voice.ts

@@ -25,7 +25,7 @@ import Task from '../Task';
 import LoggerProxy from '../../../logger-proxy';
 import MetricsManager from '../../../metrics/MetricsManager';
 import {METRIC_EVENT_NAMES} from '../../../metrics/constants';
-import {TaskState, TaskEvent} from '../state-machine';
+import {TaskState, TaskEvent, TaskActionArgs} from '../state-machine';
 import {WrapupData} from '../../config/types';
 import {getConsultMediaResourceId, getIsConferenceInProgress} from '../TaskUtils';
 
@@ -150,7 +150,10 @@ export default class Voice extends Task implements IVoice {
           });
           throw error;
         }
-      } else if (!state.matches(TaskState.HELD)) {
+      } else if (
+        !state.matches(TaskState.HELD) &&
+        !(state.matches(TaskState.CONFERENCING) && mediaHoldState === true)
+      ) {
         const error = new Error(`Cannot resume call in current state: ${currentState}`);
         LoggerProxy.error('Resume operation not allowed', {
           module: CC_FILE,
@@ -1252,9 +1255,13 @@ export default class Voice extends Task implements IVoice {
         TASK_EVENTS.TASK_CONFERENCE_TRANSFER_FAILED,
         {updateTaskData: true}
       ),
-      emitTaskOutdialFailed: this.createEmitSelfAction(TASK_EVENTS.TASK_OUTDIAL_FAILED, {
-        updateTaskData: true,
-      }),
+      emitTaskOutdialFailed: ({event}: TaskActionArgs) => {
+        if (event && 'taskData' in event && event.taskData) {
+          this.updateTaskData(event.taskData as TaskData);
+        }
+        const reason = (event as {reason?: string})?.reason || 'Outdial failed';
+        this.emit(TASK_EVENTS.TASK_OUTDIAL_FAILED, reason);
+      },
     };
   }
 }

package/test/unit/spec/services/WebCallingService.ts

@@ -200,11 +200,17 @@ describe('WebCallingService', () => {
 
     it('should reject if registration times out', async () => {
       line = callingClient.getLines().line1 as ILine;
+      jest.spyOn(global, 'setTimeout').mockImplementation(((handler: TimerHandler) => {
+        if (typeof handler === 'function') {
+          handler();
+        }
+        return 0 as unknown as NodeJS.Timeout;
+      }) as typeof setTimeout);
 
       const promise = webRTCCalling.registerWebCallingLine();
 
       await expect(promise).rejects.toThrow('WebCallingService Registration timed out');
-    }, 20003); // Increased timeout to 20 seconds
+    });
 
     it('should handle incoming calls', async () => {
       line = callingClient.getLines().line1 as ILine;

package/test/unit/spec/services/task/TaskManager.ts

@@ -1280,6 +1280,32 @@ describe('TaskManager', () => {
     sendStateMachineEventSpy.mockRestore();
   });
 
+  it('should pass taskData in OUTBOUND_FAILED event for shouldWrapUp guard evaluation', () => {
+    const task = taskManager.getTask(taskId);
+    const sendStateMachineEventSpy = jest.spyOn(task, 'sendStateMachineEvent');
+    const payload = {
+      data: {
+        type: CC_EVENTS.AGENT_OUTBOUND_FAILED,
+        interactionId: taskId,
+        reason: 'CUSTOMER_BUSY',
+        agentsPendingWrapUp: ['agent-123'],
+        interaction: {
+          outboundType: 'OUTDIAL',
+          isTerminated: true,
+        },
+      },
+    };
+    webSocketManagerMock.emit('message', JSON.stringify(payload));
+    const stateMachineEvent = expectLastStateMachineEvent(
+      sendStateMachineEventSpy,
+      TaskEvent.OUTBOUND_FAILED
+    );
+    expect(stateMachineEvent?.taskData).toBeDefined();
+    expect(stateMachineEvent?.taskData?.agentsPendingWrapUp).toEqual(['agent-123']);
+    expect(stateMachineEvent?.taskData?.interaction?.outboundType).toBe('OUTDIAL');
+    sendStateMachineEventSpy.mockRestore();
+  });
+
   it('should handle AGENT_OUTBOUND_FAILED gracefully when task is undefined', () => {
     const payload = {
       data: {

package/test/unit/spec/services/task/TaskUtils.ts

@@ -450,6 +450,14 @@ describe('TaskUtils', () => {
       expect(getIsCustomerInCall(interaction, interactionId)).toBe(true);
     });
 
+    it('getIsCustomerInCall returns false when participants map is missing', () => {
+      const interaction = createInteraction(
+        {[interactionId]: {mType: 'mainCall', participants: ['c1']}},
+        undefined
+      );
+      expect(getIsCustomerInCall(interaction, interactionId)).toBe(false);
+    });
+
     it('getConferenceParticipantsCount counts active agents only', () => {
       const interaction = createInteraction(
         {[interactionId]: {mType: 'mainCall', participants: ['a1', 'a2', 'c1']}},
@@ -458,6 +466,14 @@ describe('TaskUtils', () => {
       expect(getConferenceParticipantsCount(interaction, interactionId)).toBe(2);
     });
 
+    it('getConferenceParticipantsCount returns 0 when participants map is missing', () => {
+      const interaction = createInteraction(
+        {[interactionId]: {mType: 'mainCall', participants: ['a1', 'a2', 'c1']}},
+        undefined
+      );
+      expect(getConferenceParticipantsCount(interaction, interactionId)).toBe(0);
+    });
+
     it('isSecondaryAgent returns true for consult with parentInteractionId', () => {
       const interaction = createInteraction();
       interaction.callProcessingDetails = {relationshipType: 'consult', parentInteractionId: 'parent-456'};