@webex/contact-center 3.12.0-task-refactor.7 → 3.12.0-task-refactor.8

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

@@ -66,6 +66,20 @@ export function getDefaultUIControls(): TaskUIControls {
   );
 }
 
+/** Consult media must exist on the interaction payload, not only as a stale resource id. */
+function hasConsultMediaInInteraction(
+  interaction: TaskData['interaction'] | undefined,
+  consultMediaResourceId?: string
+): boolean {
+  const media = interaction?.media ?? {};
+  const hasConsultLeg = Object.values(media).some((entry: any) => entry?.mType === 'consult');
+
+  if (hasConsultLeg) return true;
+  if (!consultMediaResourceId) return false;
+
+  return Boolean(media[consultMediaResourceId]);
+}
+
 function computeVoiceInteractionUIControls(
   state: TaskState,
   context: TaskContext,
@@ -78,8 +92,8 @@ function computeVoiceInteractionUIControls(
     return getDefaultInteractionUIControls();
   }
 
-  // Essential data
-  const taskData = context.taskData ?? fallbackTaskData ?? null;
+  // Prefer live task.data (fallback) over stale state-machine snapshot during multi-login sync.
+  const taskData = fallbackTaskData ?? context.taskData ?? null;
   const interaction = taskData?.interaction;
   const mainCallId = interaction?.mainInteractionId || taskData?.interactionId;
   const isWebrtc = config.voiceVariant === VOICE_VARIANT.WEBRTC;
@@ -125,7 +139,6 @@ function computeVoiceInteractionUIControls(
   // Backend sends destinationType as 'EP-DN'; SDK method uses 'entryPoint' — check both.
   const isEpDnConsult =
     consultDestinationType === 'entryPoint' || consultDestinationType === ('EP-DN' as any);
-  const isConsultDestinationReady = consultDestinationAgentJoined || isEpDnConsult;
 
   const stateImpliesHeld = state === TaskState.HELD || state === TaskState.RESUME_INITIATING;
   const stateImpliesConnected =
@@ -151,9 +164,32 @@ function computeVoiceInteractionUIControls(
   const selfParticipant = selfAgentId ? interaction?.participants?.[selfAgentId] : null;
   const selfInConsultCall =
     Boolean(selfAgentId) && Boolean(consultMedia?.participants?.includes(selfAgentId as string));
-  const conferenceActive = isConferencing || conferenceFromBackend || consultFromConference;
+  const hasConsultMedia = hasConsultMediaInInteraction(
+    interaction,
+    taskData?.consultMediaResourceId
+  );
+  const isConsultEndedForSelf =
+    taskData?.type === 'AgentConsultEnded' ||
+    taskData?.type === 'AgentConsultFailed' ||
+    (selfParticipant?.consultState === 'consultCompleted' &&
+      !hasConsultMedia &&
+      taskData?.isConsulted === false);
+  const effectiveConsultInitiator = isConsultEndedForSelf ? false : consultInitiator;
+  const effectiveConsultCallHeld = isConsultEndedForSelf ? false : consultCallHeld;
+  const effectiveConsultFromConference = isConsultEndedForSelf ? false : consultFromConference;
+  const effectiveConsultDestinationAgentJoined = isConsultEndedForSelf
+    ? false
+    : consultDestinationAgentJoined;
+  // After a consult ends for self, the backend stops sending consult media but the merged
+  // task.data can still carry the stale consult-media entry (reconcileData never deletes keys).
+  // Treat it as gone so post-consult main-leg controls (consult retry) are not blocked.
+  const effectiveHasConsultMedia = isConsultEndedForSelf ? false : hasConsultMedia;
+  const isConsultDestinationReady = effectiveConsultDestinationAgentJoined || isEpDnConsult;
+  const conferenceActive =
+    isConferencing || conferenceFromBackend || effectiveConsultFromConference;
   // Treat consult initiator as "in conference" even if mainCall participant list lags while consulting.
-  const inConference = conferenceActive && (isConferencing || selfInMainCall || consultInitiator);
+  const inConference =
+    conferenceActive && (isConferencing || selfInMainCall || effectiveConsultInitiator);
 
   // Check if this is a consulted agent (must be after isConsulting is computed).
   const isSoleAgentOnCall =
@@ -162,7 +198,7 @@ function computeVoiceInteractionUIControls(
     inConference || isSoleAgentOnCall
       ? false
       : getIsConsultedAgentForControls(taskData, context, isConsulting) ||
-        (!consultInitiator &&
+        (!effectiveConsultInitiator &&
           (selfParticipant?.isConsulted === true ||
             selfParticipant?.consultState === 'consulting'));
 
@@ -177,13 +213,10 @@ function computeVoiceInteractionUIControls(
 
   // Consulted agents have limited controls until they're in conference or wrapup
   // Use inConference (not isConferencing) so controls remain enabled after state downgrade
-  const hasFullControls = !isConsulted || consultInitiator || inConference || isWrappingUp;
+  const hasFullControls = !isConsulted || effectiveConsultInitiator || inConference || isWrappingUp;
   const consultOwnedBySelf =
-    consultInitiator || (Boolean(selfAgentId) && taskData?.consultingAgentId === selfAgentId);
-  const hasConsultMedia = Boolean(
-    taskData?.consultMediaResourceId ||
-      Object.values(interaction?.media ?? {}).some((media: any) => media?.mType === 'consult')
-  );
+    effectiveConsultInitiator ||
+    (Boolean(selfAgentId) && taskData?.consultingAgentId === selfAgentId);
   const selfConsultPendingOnConsultMedia =
     selfParticipant?.consultState === 'consultInitiated' &&
     !taskData?.isConsulted &&
@@ -207,17 +240,18 @@ function computeVoiceInteractionUIControls(
       })
   );
   const isHydratedConferenceConsultPending =
-    inConference && selfConsultPendingOnConsultMedia && !consultDestinationAgentJoined;
+    inConference && selfConsultPendingOnConsultMedia && !effectiveConsultDestinationAgentJoined;
   const hasParallelConsultLeg =
+    !isConsultEndedForSelf &&
     consultOwnedBySelf &&
     !isConsulting &&
     !isConsulted &&
-    (consultInProgress || consultCallHeld || hasConsultMedia);
-  const activeLegForConferenceConsult = consultCallHeld ? 'main' : 'consult';
+    (consultInProgress || effectiveConsultCallHeld || hasConsultMedia);
+  const activeLegForConferenceConsult = effectiveConsultCallHeld ? 'main' : 'consult';
   const isCurrentLegActive = currentLeg === activeLegForConferenceConsult;
   const isConferenceConsultTransferContext =
-    inConference && consultInitiator && hasConsultMedia && isConsultDestinationReady;
-  const consultLegOnHold = isConsulting && consultCallHeld;
+    inConference && effectiveConsultInitiator && hasConsultMedia && isConsultDestinationReady;
+  const consultLegOnHold = isConsulting && effectiveConsultCallHeld;
   const callProcessingDetails = interaction?.callProcessingDetails as
     | {conferenceHoldParticipant?: boolean | string}
     | undefined;
@@ -280,6 +314,61 @@ function computeVoiceInteractionUIControls(
     currentLeg === 'main' && inConference && consultInProgress && !selfOnConsultLeg;
   const allowHeldMainLegControlsForNonInitiator =
     showMainLegConferenceControlsDuringConsult && !isHydratedConferenceConsultPending;
+  const isConsultRequestedPhase =
+    isConsultPendingBeforeJoin &&
+    !isConsulted &&
+    (consultInitiator ||
+      (Boolean(selfAgentId) &&
+        selfParticipant?.consultState === 'consultInitiated' &&
+        taskData?.agentId === selfAgentId));
+  const isConsultUnansweredFailure =
+    currentLeg === 'main' &&
+    !inConference &&
+    !taskData?.isConsulted &&
+    !effectiveHasConsultMedia &&
+    isHeld &&
+    selfParticipant?.consultState === 'consultCompleted' &&
+    (taskData?.type === 'AgentConsultFailed' ||
+      taskData?.type === 'AgentConsultEnded' ||
+      isConsultEndedForSelf);
+
+  if (isConsultUnansweredFailure) {
+    const recordingControl =
+      recordingControlsAvailable && config.isRecordingEnabled && !inConference
+        ? VISIBLE_ENABLED
+        : DISABLED;
+
+    return {
+      ...getDefaultInteractionUIControls(),
+      hold: VISIBLE_ENABLED,
+      transfer: VISIBLE_ENABLED,
+      consult: VISIBLE_ENABLED,
+      recording: recordingControl,
+      end: VISIBLE_DISABLED,
+    };
+  }
+
+  if (isConsultRequestedPhase) {
+    if (currentLeg === 'main') {
+      return {
+        ...getDefaultInteractionUIControls(),
+        transfer: VISIBLE_DISABLED,
+        conference: VISIBLE_DISABLED,
+        end: VISIBLE_DISABLED,
+      };
+    }
+
+    if (currentLeg === 'consult') {
+      return {
+        ...getDefaultInteractionUIControls(),
+        endConsult: VISIBLE_ENABLED,
+        switch: VISIBLE_DISABLED,
+        transfer: VISIBLE_DISABLED,
+        transferConference: inConference ? VISIBLE_DISABLED : DISABLED,
+        mergeToConference: VISIBLE_DISABLED,
+      };
+    }
+  }
 
   return {
     // Accept/Decline: Voice tasks in offered state
@@ -300,7 +389,10 @@ function computeVoiceInteractionUIControls(
     hold: (() => {
       if (!hasFullControls) return DISABLED;
       if (forceHeldPostConsultControls) return VISIBLE_ENABLED;
-      if (consultOwnedBySelf && (isConsulting || hasParallelConsultLeg || consultCallHeld)) {
+      if (
+        consultOwnedBySelf &&
+        (isConsulting || hasParallelConsultLeg || effectiveConsultCallHeld)
+      ) {
         return DISABLED;
       }
       if (hasParallelConsultLeg) return DISABLED;
@@ -319,7 +411,17 @@ function computeVoiceInteractionUIControls(
       if (!isWebrtc) return DISABLED;
       if (isWrappingUp) return DISABLED;
       if (currentLeg === 'consult' && !selfInConsultCall) return DISABLED;
-      if ((isConsulting || hasParallelConsultLeg) && !isCurrentLegActive) return VISIBLE_DISABLED;
+      // The consulted agent has no separate consult leg; their main leg is the active call, so
+      // mute stays available while they consult (the heuristic below targets the initiator's
+      // inactive leg, not the consultee's only leg).
+      const isConsultedActiveMainLeg = isConsulted && currentLeg === 'main';
+      if (
+        (isConsulting || hasParallelConsultLeg) &&
+        !isCurrentLegActive &&
+        !isConsultedActiveMainLeg
+      ) {
+        return VISIBLE_DISABLED;
+      }
       if (isConsulting) return VISIBLE_ENABLED;
 
       if (isConnected || isHeld || isConferencing) {
@@ -395,6 +497,18 @@ function computeVoiceInteractionUIControls(
     consult: (() => {
       const isConnectedOrHeld = state === TaskState.CONNECTED || state === TaskState.HELD;
 
+      if (
+        isHeld &&
+        !inConference &&
+        !effectiveHasConsultMedia &&
+        selfParticipant?.consultState === 'consultCompleted' &&
+        !taskData?.isConsulted
+      ) {
+        const canRetryConsult = !maxParticipants && customerPresent && !otherAgentConsultInProgress;
+
+        return {isVisible: true, isEnabled: canRetryConsult};
+      }
+
       if (inConference && nonOwnerPostConsultCompletedHeldMainLeg) return VISIBLE_DISABLED;
       if (hasParallelConsultLeg) return DISABLED;
       if (!hasFullControls || !(isConnectedOrHeld || inConference)) {
@@ -591,10 +705,21 @@ function getVoiceLegState(
     };
   }
 
-  const taskData = context.taskData ?? fallbackTaskData ?? null;
+  const taskData = fallbackTaskData ?? context.taskData ?? null;
   const interaction = taskData?.interaction;
   const mainCallId = interaction?.mainInteractionId || taskData?.interactionId;
   const selfAgentId = config.agentId ?? taskData?.agentId;
+  const selfParticipant = selfAgentId ? interaction?.participants?.[selfAgentId] : null;
+  const hasConsultMedia = hasConsultMediaInInteraction(
+    interaction,
+    taskData?.consultMediaResourceId
+  );
+  const isConsultEndedForSelf =
+    taskData?.type === 'AgentConsultEnded' ||
+    taskData?.type === 'AgentConsultFailed' ||
+    (selfParticipant?.consultState === 'consultCompleted' &&
+      !hasConsultMedia &&
+      taskData?.isConsulted === false);
   const consultInProgress = getIsConsultInProgressForConferenceControls(
     interaction,
     mainCallId,
@@ -607,30 +732,48 @@ function getVoiceLegState(
   const consultOwnedBySelf =
     context.consultInitiator ||
     (Boolean(selfAgentId) && taskData?.consultingAgentId === selfAgentId);
-  const hasConsultMedia = Boolean(
-    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 isConsultUnansweredFailure =
+    !taskData?.isConsulted &&
+    !hasConsultMedia &&
+    selfParticipant?.consultState === 'consultCompleted' &&
+    Boolean(mainCallId && taskData?.interaction?.media?.[mainCallId]?.isHold === true) &&
+    taskData?.interaction?.state !== 'conference' &&
+    !getIsConferenceInProgress(taskData);
   const hasConsultLeg = Boolean(
-    !interaction?.isTerminated &&
-      ((consultOwnedBySelf && !taskData?.isConsulted) ||
-        selfConsultingOnConsultMedia ||
-        selfConsultPendingOnConsultMedia) &&
+    !isConsultEndedForSelf &&
+      !interaction?.isTerminated &&
+      !isConsultUnansweredFailure &&
+      (consultOwnedBySelf || selfConsultingOnConsultMedia || selfConsultPendingOnConsultMedia) &&
       (consultInProgress || isConsultingState || context.consultCallHeld || hasConsultMedia)
   );
 
   if (!hasConsultLeg) {
+    let mainState = currentState;
+    if (isConsultEndedForSelf && taskData?.interaction) {
+      const resolvedMainId = taskData.interaction.mainInteractionId || taskData.interactionId;
+      const isMainHeld = Boolean(
+        resolvedMainId && taskData.interaction.media?.[resolvedMainId]?.isHold === true
+      );
+
+      if (taskData.interaction.state === 'conference' || getIsConferenceInProgress(taskData)) {
+        mainState = TaskState.CONFERENCING;
+      } else if (isMainHeld || taskData.interaction.state === 'hold') {
+        mainState = TaskState.HELD;
+      } else {
+        mainState = TaskState.CONNECTED;
+      }
+    }
+
     return {
       hasConsultLeg: false,
       activeLeg: 'main',
-      mainState: currentState,
+      mainState,
       consultState: TaskState.CONSULTING,
     };
   }

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

@@ -89,6 +89,67 @@ describe('Task (base class)', () => {
     expect((task.data as any).foo).toBeUndefined();
   });
 
+  it('drops stale interaction.media/participants entries the backend no longer sends (merge keeps other fields)', () => {
+    const withConsult = createTaskData({
+      interaction: {
+        callAssociatedData: {a: {value: 'keep-me'}},
+        media: {
+          main: {mediaResourceId: 'main', mType: 'mainCall', isHold: true},
+          consult: {mediaResourceId: 'consult', mType: 'consult', isHold: false},
+        },
+        participants: {
+          'customer-1': {id: 'customer-1', pType: 'Customer'},
+          'agent-1': {id: 'agent-1', pType: 'Agent'},
+          'agent-2': {id: 'agent-2', pType: 'Agent', consultState: 'consulting'},
+        },
+      } as any,
+    }) as unknown as TaskData;
+    task.updateTaskData(withConsult, true);
+
+    // Backend resume snapshot: consult leg gone (only main media + main participants).
+    const resumeData = createTaskData({
+      interaction: {
+        media: {main: {mediaResourceId: 'main', mType: 'mainCall', isHold: false}},
+        participants: {
+          'customer-1': {id: 'customer-1', pType: 'Customer'},
+          'agent-1': {id: 'agent-1', pType: 'Agent', consultState: null},
+        },
+      } as any,
+    }) as unknown as TaskData;
+    task.updateTaskData(resumeData);
+
+    const interaction = (task.data as any).interaction;
+    // Stale consult media + consultee participant (absent from the resume snapshot) are removed.
+    expect(interaction.media.consult).toBeUndefined();
+    expect(interaction.participants['agent-2']).toBeUndefined();
+    // Entries still present in the incoming snapshot survive and reflect the new values.
+    expect(interaction.media.main).toBeDefined();
+    expect(interaction.media.main.isHold).toBe(false);
+    expect(interaction.participants['agent-1']).toBeDefined();
+    expect(interaction.participants['customer-1']).toBeDefined();
+    // Unrelated merge-able fields (CAD) are preserved.
+    expect(interaction.callAssociatedData.a.value).toBe('keep-me');
+  });
+
+  it('does not touch interaction maps when the incoming payload omits them', () => {
+    const withConsult = createTaskData({
+      interaction: {
+        media: {main: {mediaResourceId: 'main'}, consult: {mediaResourceId: 'consult'}},
+        participants: {'agent-1': {id: 'agent-1'}, 'agent-2': {id: 'agent-2'}},
+      } as any,
+    }) as unknown as TaskData;
+    task.updateTaskData(withConsult, true);
+
+    // A partial update with no interaction maps must not prune existing media/participants.
+    task.updateTaskData({foo: 'changed'} as unknown as TaskData);
+
+    const interaction = (task.data as any).interaction;
+    expect(interaction.media.main).toBeDefined();
+    expect(interaction.media.consult).toBeDefined();
+    expect(interaction.participants['agent-1']).toBeDefined();
+    expect(interaction.participants['agent-2']).toBeDefined();
+  });
+
   it('getUIControls returns default controls shape for idle voice task', () => {
     const controls = task.uiControls;
     const mainControls = controls.main;

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

@@ -13,6 +13,7 @@ import {
   isSecondaryAgent,
   isSecondaryEpDnAgent,
   getConsultMediaResourceId,
+  getIsConsultInProgressForConferenceControls,
 } from '../../../../../src/services/task/TaskUtils';
 import {ITask, Interaction, TaskData} from '../../../../../src/services/task/types';
 import {LoginOption} from '../../../../../src/types';
@@ -571,4 +572,68 @@ describe('TaskUtils', () => {
       expect(result).toBe('direct-id');
     });
   });
+
+  describe('getIsConsultInProgressForConferenceControls', () => {
+    it('returns false when consultee is reserved but has not joined (RONA)', () => {
+      const interaction = {
+        participants: {
+          'agent-1': {id: 'agent-1', pType: 'Agent', hasLeft: false, isConsulted: false},
+          'agent-2': {
+            id: 'agent-2',
+            pType: 'Agent',
+            hasLeft: false,
+            hasJoined: false,
+            isConsulted: true,
+            consultState: 'consultReserved',
+          },
+          'customer-1': {id: 'customer-1', pType: 'Customer', hasLeft: false},
+        },
+        media: {
+          'interaction-1': {
+            mType: 'mainCall',
+            participants: ['customer-1', 'agent-1'],
+          },
+          'consult-media': {
+            mType: 'consult',
+            participants: ['agent-2', 'agent-1'],
+          },
+        },
+      } as any;
+
+      expect(
+        getIsConsultInProgressForConferenceControls(interaction, 'interaction-1', 'agent-1')
+      ).toBe(false);
+    });
+
+    it('returns true when consultee is actively consulting', () => {
+      const interaction = {
+        participants: {
+          'agent-1': {id: 'agent-1', pType: 'Agent', hasLeft: false, isConsulted: false},
+          'agent-2': {
+            id: 'agent-2',
+            pType: 'Agent',
+            hasLeft: false,
+            hasJoined: true,
+            isConsulted: true,
+            consultState: 'consulting',
+          },
+          'customer-1': {id: 'customer-1', pType: 'Customer', hasLeft: false},
+        },
+        media: {
+          'interaction-1': {
+            mType: 'mainCall',
+            participants: ['customer-1', 'agent-1'],
+          },
+          'consult-media': {
+            mType: 'consult',
+            participants: ['agent-2', 'agent-1'],
+          },
+        },
+      } as any;
+
+      expect(
+        getIsConsultInProgressForConferenceControls(interaction, 'interaction-1', 'agent-1')
+      ).toBe(true);
+    });
+  });
 });