@webex/contact-center 3.11.0 → 3.12.0-llmrefactor.2

package/dist/services/task/state-machine/uiControlsComputer.js

@@ -0,0 +1,603 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.computeUIControls = computeUIControls;
+exports.getDefaultUIControls = getDefaultUIControls;
+exports.haveUIControlsChanged = haveUIControlsChanged;
+var _types = require("../types");
+var _constants = require("./constants");
+var _TaskUtils = require("../TaskUtils");
+/**
+ * UI Controls Computer - Centralized logic for computing UI control states
+ */
+
+const DISABLED = {
+  isVisible: false,
+  isEnabled: false
+};
+const VISIBLE_ENABLED = {
+  isVisible: true,
+  isEnabled: true
+};
+const VISIBLE_DISABLED = {
+  isVisible: true,
+  isEnabled: false
+};
+function getDefaultInteractionUIControls() {
+  return {
+    accept: DISABLED,
+    decline: DISABLED,
+    hold: DISABLED,
+    mute: DISABLED,
+    end: DISABLED,
+    transfer: DISABLED,
+    consult: DISABLED,
+    consultTransfer: DISABLED,
+    endConsult: DISABLED,
+    recording: DISABLED,
+    conference: DISABLED,
+    wrapup: DISABLED,
+    exitConference: DISABLED,
+    transferConference: DISABLED,
+    mergeToConference: DISABLED,
+    switch: DISABLED
+  };
+}
+function createTaskUIControls(main, consult, activeLeg) {
+  return {
+    main,
+    consult,
+    activeLeg
+  };
+}
+function getDefaultUIControls() {
+  return createTaskUIControls(getDefaultInteractionUIControls(), getDefaultInteractionUIControls(), 'main');
+}
+
+/** Consult media must exist on the interaction payload, not only as a stale resource id. */
+function hasConsultMediaInInteraction(interaction, consultMediaResourceId) {
+  const media = interaction?.media ?? {};
+  const hasConsultLeg = Object.values(media).some(entry => entry?.mType === 'consult');
+  if (hasConsultLeg) return true;
+  if (!consultMediaResourceId) return false;
+  return Boolean(media[consultMediaResourceId]);
+}
+
+/** True when this agent is actively initiating a consult, not a stale context flag alone (CAI-8329). */
+function isSelfActiveConsultInitiator(consultInitiator, selfAgentId, selfParticipant, selfInConsultCall, consultingAgentId) {
+  return consultInitiator && (selfParticipant?.consultState === 'consultInitiated' || selfParticipant?.consultState === 'consulting' || selfInConsultCall || Boolean(consultingAgentId) && consultingAgentId === selfAgentId);
+}
+function computeVoiceInteractionUIControls(state, context, config, fallbackTaskData, currentLeg = 'main') {
+  // Early exit for idle
+  if (state === _constants.TaskState.IDLE) {
+    return getDefaultInteractionUIControls();
+  }
+
+  // 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 === _types.VOICE_VARIANT.WEBRTC;
+  const isOutdial = interaction?.outboundType === 'OUTDIAL';
+  const serverHold = (0, _TaskUtils.getServerHoldStateForControls)(context, mainCallId, fallbackTaskData);
+
+  // Backend-derived checks
+  const customerInCall = interaction && mainCallId ? (0, _TaskUtils.getIsCustomerInCall)(interaction, mainCallId) : false;
+  // EP-DN/secondary legs can have incomplete media participant lists; fall back to participants map.
+  const customerPresent = customerInCall || Boolean(interaction && interaction.participants && Object.values(interaction.participants).some(p => p?.pType === 'Customer' && !p?.hasLeft));
+  const participantCount = interaction && mainCallId ? (0, _TaskUtils.getConferenceParticipantsCount)(interaction, mainCallId) : 0;
+  const maxParticipants = participantCount >= _constants.MAX_PARTICIPANTS_IN_MULTIPARTY_CONFERENCE;
+  const selfAgentId = config.agentId ?? taskData?.agentId;
+  const consultInProgress = (0, _TaskUtils.getIsConsultInProgressForConferenceControls)(interaction, mainCallId, selfAgentId);
+  const conferenceFromBackend = taskData ? (0, _TaskUtils.getIsConferenceInProgress)(taskData) : false;
+  // Note: ownership is used by some controls; keep computations local to those controls
+
+  // Context flags (set by state machine actions)
+  const {
+    consultInitiator,
+    consultDestinationAgentJoined,
+    consultDestinationType,
+    consultCallHeld,
+    consultFromConference,
+    hideBlindTransferForEpDnPendingMerge
+  } = context;
+  const {
+    recordingControlsAvailable
+  } = context;
+
+  // EP_DN consults are "ready" as soon as the consult is created (EP accepts routing immediately).
+  // Backend sends destinationType as 'EP-DN'; SDK method uses 'entryPoint' — check both.
+  const isEpDnConsult = consultDestinationType === 'entryPoint' || consultDestinationType === 'EP-DN';
+  const stateImpliesHeld = state === _constants.TaskState.HELD || state === _constants.TaskState.RESUME_INITIATING;
+  const stateImpliesConnected = state === _constants.TaskState.CONNECTED || state === _constants.TaskState.HOLD_INITIATING;
+  const isHeld = stateImpliesHeld || serverHold === true;
+  const isConnected = stateImpliesConnected || !stateImpliesHeld && serverHold === false;
+
+  // State categories for cleaner logic
+  const isConsulting = state === _constants.TaskState.CONSULTING || state === _constants.TaskState.CONSULT_INITIATING || state === _constants.TaskState.CONF_INITIATING;
+  const isConferencing = state === _constants.TaskState.CONFERENCING;
+  const isWrappingUp = state === _constants.TaskState.WRAPPING_UP;
+  const selfInMainCall = Boolean(selfAgentId) && Boolean(mainCallId) && Boolean(interaction?.media?.[mainCallId]?.participants?.includes(selfAgentId));
+  const consultMedia = Object.values(interaction?.media ?? {}).find(media => media?.mediaResourceId === taskData?.consultMediaResourceId || media?.mType === 'consult');
+  const selfParticipant = selfAgentId ? interaction?.participants?.[selfAgentId] : null;
+  const selfInConsultCall = Boolean(selfAgentId) && Boolean(consultMedia?.participants?.includes(selfAgentId));
+  const hasConsultMedia = hasConsultMediaInInteraction(interaction, taskData?.consultMediaResourceId);
+  const isSecondaryConsultRejectedWhileEpDnActive = taskData?.type === 'AgentConsultFailed' && hideBlindTransferForEpDnPendingMerge;
+  const isSelfConsultCompleted = selfParticipant?.consultState === 'consultCompleted' && taskData?.isConsulted === false;
+  const isConsultEndedForSelf = taskData?.type === 'AgentConsultEnded' || taskData?.type === 'AgentConsultFailed' && !isSecondaryConsultRejectedWhileEpDnActive || isSelfConsultCompleted;
+  // EP-DN consult merged to conference before destination joins main (CAI-8329).
+  // Context flag is set in actions.ts; treat as main-leg conference UI only here.
+  const isEpDnPendingConferenceMergeUi = hideBlindTransferForEpDnPendingMerge && participantCount <= 1 && (isConferencing || conferenceFromBackend || interaction?.state === _constants.INTERACTION_STATE.POST_CALL) && !isConsultEndedForSelf;
+  const isEpDnPostCallCustomerLeft = isEpDnPendingConferenceMergeUi && !customerPresent;
+  const effectiveConsultInProgress = isEpDnPendingConferenceMergeUi ? false : consultInProgress;
+  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 || effectiveConsultInitiator);
+
+  // Check if this is a consulted agent (must be after isConsulting is computed).
+  const isSoleAgentOnCall = participantCount <= 1 && selfInMainCall && !isConsulting && !inConference;
+  const isConsulted = inConference || isSoleAgentOnCall ? false : (0, _TaskUtils.getIsConsultedAgentForControls)(taskData, context, isConsulting) || !effectiveConsultInitiator && (selfParticipant?.isConsulted === true || selfParticipant?.consultState === 'consulting');
+
+  // Active call = can perform call operations
+  const isActive = state === _constants.TaskState.CONNECTED || state === _constants.TaskState.HELD || state === _constants.TaskState.HOLD_INITIATING || state === _constants.TaskState.RESUME_INITIATING || isConsulting || isConferencing;
+
+  // 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 || effectiveConsultInitiator || inConference || isWrappingUp;
+  const selfActiveConsultInitiator = isSelfActiveConsultInitiator(effectiveConsultInitiator, selfAgentId, selfParticipant, selfInConsultCall, taskData?.consultingAgentId);
+  const consultOwnedBySelf = !isEpDnPendingConferenceMergeUi && selfActiveConsultInitiator;
+  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 => {
+    if (!participant || participant.hasLeft) return false;
+    if (participant.id === selfAgentId) return false;
+    if (String(participant.pType ?? '').toUpperCase() !== 'AGENT') return false;
+    return participant.consultState === 'consultInitiated' || participant.consultState === 'consultReserved' || participant.consultState === 'consulting' || participant.currentState === 'consulting';
+  }));
+  const isHydratedConferenceConsultPending = inConference && selfConsultPendingOnConsultMedia && !effectiveConsultDestinationAgentJoined;
+  const hasParallelConsultLeg = !isConsultEndedForSelf && consultOwnedBySelf && !isConsulting && !isConsulted && (effectiveConsultInProgress || effectiveConsultCallHeld || hasConsultMedia);
+  const activeLegForConferenceConsult = effectiveConsultCallHeld ? 'main' : 'consult';
+  const isCurrentLegActive = currentLeg === activeLegForConferenceConsult;
+  const isConferenceConsultTransferContext = inConference && selfActiveConsultInitiator && hasConsultMedia && isConsultDestinationReady;
+  const consultLegOnHold = isConsulting && effectiveConsultCallHeld;
+  const callProcessingDetails = interaction?.callProcessingDetails;
+  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' || effectiveConsultInProgress || isConsulting);
+  const hideExitConferenceDuringActiveConsultFromConference = inConference && selfActiveConsultInitiator && consultDestinationAgentJoined && (isConsulting || taskData?.type === 'AgentConsulting' || selfParticipant?.consultState === 'consulting');
+  const hideExitConferenceOnMainLegForEpDnConsultFromConference = currentLeg === 'main' && inConference && consultFromConference && selfActiveConsultInitiator && (isConsulting || effectiveConsultInProgress || taskData?.type === 'AgentConsultCreated' || taskData?.type === 'AgentConsulting' || selfParticipant?.consultState === 'consultInitiated' || selfParticipant?.consultState === 'consulting');
+  const forceHeldPostConsultControls = !hideExitConferenceWhileConsultPending && (postDeclineHeldMainLeg || postConsultCompletedHeldMainLeg);
+  const selfOnConsultLeg = selfParticipant?.consultState === 'consulting' || selfParticipant?.currentState === 'consulting';
+  const showMainLegConferenceControlsDuringConsult = currentLeg === 'main' && inConference && effectiveConsultInProgress && !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);
+  // EP-DN consult merged to conference before a second agent joins main: hide blind transfer (CAI-8329).
+  const shouldHideBlindTransferForEpDnPendingConferenceMerge = isEpDnPendingConferenceMergeUi;
+  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 && !isEpDnPendingConferenceMergeUi) {
+    if (currentLeg === 'main') {
+      return {
+        ...getDefaultInteractionUIControls(),
+        transfer: shouldHideBlindTransferForEpDnPendingConferenceMerge ? DISABLED : 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
+    // 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 === _constants.TaskState.OFFERED && !interaction?.isTerminated ? {
+      isVisible: true,
+      isEnabled: isWebrtc && !isOutdial
+    } : DISABLED,
+    decline: (() => {
+      if (!isWebrtc || state !== _constants.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 (isEpDnPostCallCustomerLeft) return VISIBLE_DISABLED;
+      if (forceHeldPostConsultControls) return VISIBLE_ENABLED;
+      if (consultOwnedBySelf && (isConsulting || hasParallelConsultLeg || effectiveConsultCallHeld)) {
+        return DISABLED;
+      }
+      if (hasParallelConsultLeg) return DISABLED;
+      if (state === _constants.TaskState.OFFERED) return DISABLED;
+      if (isWrappingUp) return DISABLED;
+      // Visibility: connected || held || inConference
+      if (!(isConnected || isHeld || inConference)) return DISABLED;
+      // Enabled: (connected || held) && !inConference && !isConsulting
+      const canHold = (isConnected || isHeld) && !inConference && !isConsulting;
+      return canHold ? VISIBLE_ENABLED : VISIBLE_DISABLED;
+    })(),
+    // Mute: WebRTC only, active calls; hidden entirely during wrapup
+    mute: (() => {
+      if (!isWebrtc) return DISABLED;
+      if (isWrappingUp) return DISABLED;
+      if (isEpDnPostCallCustomerLeft && inConference) return VISIBLE_DISABLED;
+      if (currentLeg === 'consult' && !selfInConsultCall) return 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) {
+        if (inConference) return VISIBLE_ENABLED;
+        return isHeld ? VISIBLE_DISABLED : VISIBLE_ENABLED;
+      }
+      return DISABLED;
+    })(),
+    // 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 && !isWebrtc) return DISABLED;
+      if (hasParallelConsultLeg) {
+        return isConnected && isEpDnConsult ? VISIBLE_ENABLED : VISIBLE_DISABLED;
+      }
+      if (isConsulting) {
+        if (currentLeg === 'consult' && consultCallHeld) return DISABLED;
+        return consultInitiator && consultCallHeld ? VISIBLE_ENABLED : DISABLED;
+      }
+      if (inConference) {
+        if (isConsulted) return DISABLED;
+        if (forceHeldPostConsultControls) return VISIBLE_DISABLED;
+        if (effectiveConsultInProgress) return VISIBLE_DISABLED;
+        return isWrappingUp ? VISIBLE_DISABLED : VISIBLE_ENABLED;
+      }
+      if (!hasFullControls) return DISABLED;
+      if (isActive) return isHeld || isWrappingUp ? VISIBLE_DISABLED : VISIBLE_ENABLED;
+      return DISABLED;
+    })(),
+    // 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 (shouldHideBlindTransferForEpDnPendingConferenceMerge) return DISABLED;
+        if (state === _constants.TaskState.CONNECTED) return VISIBLE_ENABLED;
+        if (state === _constants.TaskState.HELD) return VISIBLE_DISABLED;
+      }
+      if (isConsulting) {
+        if (!consultInitiator) return DISABLED;
+        if (!customerPresent) return VISIBLE_DISABLED;
+        if (consultLegOnHold) return VISIBLE_DISABLED;
+        return isConsultDestinationReady ? VISIBLE_ENABLED : VISIBLE_DISABLED;
+      }
+      if (!hasFullControls) return DISABLED;
+      if (inConference) {
+        // Real conference (multiple agents): transfer is hidden
+        // Pending conference (only self agent): transfer remains available
+        // EP-DN consult merged before destination joins: hide blind transfer on main
+        // (Agent 2 may still be ringing on the consult leg — blind transfer causes stuck ringing)
+        if (shouldHideBlindTransferForEpDnPendingConferenceMerge) {
+          return DISABLED;
+        }
+        if (participantCount > 1) {
+          return DISABLED;
+        }
+        return customerPresent ? VISIBLE_ENABLED : DISABLED;
+      }
+      if (state === _constants.TaskState.CONNECTED || state === _constants.TaskState.HELD) return VISIBLE_ENABLED;
+      return DISABLED;
+    })(),
+    // Consult: connected/held/conference when conditions met
+    consult: (() => {
+      const isConnectedOrHeld = state === _constants.TaskState.CONNECTED || state === _constants.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)) {
+        return DISABLED;
+      }
+
+      // In conference: behavior depends on whether it's a real multi-agent conference
+      if (inConference) {
+        // Pending conference (only self agent): consult disabled
+        if (participantCount <= 1) return VISIBLE_DISABLED;
+        // Real conference: consult enabled if conditions met
+        const canFromConference = !maxParticipants && customerPresent && !effectiveConsultInProgress && !otherAgentConsultInProgress && !isConsulting;
+        return {
+          isVisible: true,
+          isEnabled: canFromConference
+        };
+      }
+
+      // Enabled conditions for connected/held
+      const canFromConnected = !maxParticipants && customerPresent && !effectiveConsultInProgress && !isConsulted;
+      return {
+        isVisible: true,
+        isEnabled: canFromConnected
+      };
+    })(),
+    // ConsultTransfer: always hidden (use transfer button)
+    consultTransfer: DISABLED,
+    // EndConsult: during consulting
+    endConsult: (() => {
+      if (!isConsulting) return DISABLED;
+      if (isConsulted && isConferencing) return DISABLED;
+      if (!isConsulted && isConferencing && !(consultInitiator && conferenceFromBackend)) {
+        return DISABLED;
+      }
+      return {
+        isVisible: true,
+        isEnabled: consultInitiator || config.isEndConsultEnabled
+      };
+    })(),
+    // Recording: connected/held/conference when backend exposes recording controls
+    recording: (() => {
+      if (!recordingControlsAvailable || !config.isRecordingEnabled) return DISABLED;
+      if (!hasFullControls || isConsulting) return DISABLED;
+      if (inConference) {
+        // Recording stays available in conference when backend exposes controls
+        // (including after EP-DN pending merge transitions to real conference — CAI-8329)
+        if (isEpDnPostCallCustomerLeft) return VISIBLE_DISABLED;
+        return VISIBLE_ENABLED;
+      }
+      if (hasParallelConsultLeg && !customerPresent) return DISABLED;
+      if (state === _constants.TaskState.CONNECTED || state === _constants.TaskState.HELD) {
+        return VISIBLE_ENABLED;
+      }
+      return DISABLED;
+    })(),
+    // 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 === _constants.TaskState.CONNECTED) {
+          return maxParticipants ? VISIBLE_DISABLED : VISIBLE_ENABLED;
+        }
+        if (state === _constants.TaskState.HELD) return VISIBLE_DISABLED;
+        return DISABLED;
+      }
+      if (!hasFullControls || !isConsulting) return DISABLED;
+      if (!consultInitiator) return DISABLED;
+      if (!customerPresent) return VISIBLE_DISABLED;
+      if (consultLegOnHold) return VISIBLE_DISABLED;
+      return isConsultDestinationReady && !maxParticipants ? VISIBLE_ENABLED : VISIBLE_DISABLED;
+    })(),
+    // Wrapup: wrapping up state
+    wrapup: isWrappingUp ? VISIBLE_ENABLED : DISABLED,
+    // ExitConference: in conference with multiple agents in main call
+    exitConference: (() => {
+      if (hideExitConferenceWhileConsultPending) return DISABLED;
+      if (hideExitConferenceOnMainLegForEpDnConsultFromConference) 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 (isEpDnPendingConferenceMergeUi) return VISIBLE_ENABLED;
+      if (participantCount <= 1) return DISABLED;
+      if (effectiveConsultInProgress) return VISIBLE_DISABLED;
+      const consultingFromConference = consultInitiator && isConsulting && conferenceFromBackend;
+      return consultingFromConference ? VISIBLE_DISABLED : VISIBLE_ENABLED;
+    })(),
+    // TransferConference: in conference with active consult, owner consulting from conference
+    transferConference: (() => {
+      if (isConferenceConsultTransferContext && !isCurrentLegActive) return VISIBLE_DISABLED;
+      const consultLegTransferAvailable = currentLeg === 'consult' && inConference && selfActiveConsultInitiator && hasConsultMedia;
+      const selfConsultingOnParticipantState = selfParticipant?.consultState === 'consulting';
+      const conferenceTransferAvailable = consultLegTransferAvailable || inConference && selfActiveConsultInitiator && hasConsultMedia && (isConsulting || effectiveConsultInProgress || selfConsultingOnParticipantState);
+      if (consultLegOnHold) return DISABLED;
+      if (hasParallelConsultLeg && !conferenceTransferAvailable) return DISABLED;
+      if (!conferenceTransferAvailable && (!inConference || !isConsulting)) return DISABLED;
+      if (!selfActiveConsultInitiator || isConsulted) return DISABLED;
+      return isConsultDestinationReady ? VISIBLE_ENABLED : VISIBLE_DISABLED;
+    })(),
+    // 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;
+      return isConsultDestinationReady && !maxParticipants ? VISIBLE_ENABLED : VISIBLE_DISABLED;
+    })(),
+    // 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;
+        if (!customerPresent) return VISIBLE_DISABLED;
+        return isConsultDestinationReady ? VISIBLE_ENABLED : VISIBLE_DISABLED;
+      }
+      if (hasParallelConsultLeg && state === _constants.TaskState.CONNECTED) {
+        return isConsultDestinationReady ? VISIBLE_ENABLED : VISIBLE_DISABLED;
+      }
+      return DISABLED;
+    })()
+  };
+}
+function computeDigitalInteractionUIControls(state, context, fallbackTaskData) {
+  const taskData = context.taskData ?? fallbackTaskData ?? null;
+  const isTerminated = taskData?.interaction?.isTerminated ?? false;
+  const isConnected = state === _constants.TaskState.CONNECTED;
+  const isWrappingUp = state === _constants.TaskState.WRAPPING_UP;
+  return {
+    accept: state === _constants.TaskState.OFFERED ? VISIBLE_ENABLED : DISABLED,
+    decline: DISABLED,
+    hold: DISABLED,
+    mute: DISABLED,
+    end: isConnected && !isWrappingUp ? VISIBLE_ENABLED : DISABLED,
+    transfer: isConnected && !isWrappingUp ? VISIBLE_ENABLED : DISABLED,
+    consult: DISABLED,
+    consultTransfer: DISABLED,
+    endConsult: DISABLED,
+    recording: DISABLED,
+    conference: DISABLED,
+    wrapup: isTerminated || isWrappingUp ? VISIBLE_ENABLED : DISABLED,
+    exitConference: DISABLED,
+    transferConference: DISABLED,
+    mergeToConference: DISABLED,
+    switch: DISABLED
+  };
+}
+function getVoiceLegState(currentState, context, config, fallbackTaskData) {
+  if (currentState === _constants.TaskState.WRAPPING_UP) {
+    return {
+      hasConsultLeg: false,
+      activeLeg: 'main',
+      mainState: currentState,
+      consultState: _constants.TaskState.CONSULTING
+    };
+  }
+  const taskData = fallbackTaskData ?? context.taskData ?? null;
+  const interaction = taskData?.interaction;
+  const mainCallId = interaction?.mainInteractionId || taskData?.interactionId;
+  const selfAgentId = config.agentId ?? taskData?.agentId;
+  if (context.hideBlindTransferForEpDnPendingMerge && taskData) {
+    const conferenceFromBackend = (0, _TaskUtils.getIsConferenceInProgress)(taskData);
+    const participantCount = interaction && mainCallId ? (0, _TaskUtils.getConferenceParticipantsCount)(interaction, mainCallId) : 0;
+    if (participantCount <= 1 && (currentState === _constants.TaskState.CONFERENCING || conferenceFromBackend)) {
+      return {
+        hasConsultLeg: false,
+        activeLeg: 'main',
+        mainState: _constants.TaskState.CONFERENCING,
+        consultState: _constants.TaskState.CONSULTING
+      };
+    }
+  }
+  const selfParticipant = selfAgentId ? interaction?.participants?.[selfAgentId] : null;
+  const hasConsultMedia = hasConsultMediaInInteraction(interaction, taskData?.consultMediaResourceId);
+  const isSecondaryConsultRejectedWhileEpDnActive = taskData?.type === 'AgentConsultFailed' && context.hideBlindTransferForEpDnPendingMerge;
+  const isSelfConsultCompleted = selfParticipant?.consultState === 'consultCompleted' && taskData?.isConsulted === false;
+  const isConsultEndedForSelf = taskData?.type === 'AgentConsultEnded' || taskData?.type === 'AgentConsultFailed' && !isSecondaryConsultRejectedWhileEpDnActive || isSelfConsultCompleted;
+  const consultInProgress = (0, _TaskUtils.getIsConsultInProgressForConferenceControls)(interaction, mainCallId, selfAgentId);
+  const isConsultingState = currentState === _constants.TaskState.CONSULTING || currentState === _constants.TaskState.CONSULT_INITIATING || currentState === _constants.TaskState.CONF_INITIATING;
+  const consultMedia = Object.values(interaction?.media ?? {}).find(media => media?.mediaResourceId === taskData?.consultMediaResourceId || media?.mType === 'consult');
+  const selfInConsultCall = Boolean(selfAgentId) && Boolean(consultMedia?.participants?.includes(selfAgentId));
+  const selfActiveConsultInitiator = isSelfActiveConsultInitiator(context.consultInitiator, selfAgentId, selfParticipant, selfInConsultCall, taskData?.consultingAgentId);
+  const consultOwnedBySelf = !context.hideBlindTransferForEpDnPendingMerge && selfActiveConsultInitiator;
+  const selfConsultPendingOnConsultMedia = selfParticipant?.consultState === 'consultInitiated' && !taskData?.isConsulted && hasConsultMedia;
+  const selfConsultingOnConsultMedia = selfParticipant?.consultState === 'consulting' && hasConsultMedia;
+  const isConsultUnansweredFailure = isSelfConsultCompleted && Boolean(mainCallId && taskData?.interaction?.media?.[mainCallId]?.isHold === true) && taskData?.interaction?.state !== 'conference' && !(0, _TaskUtils.getIsConferenceInProgress)(taskData);
+  const hasConsultLeg = Boolean(!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' || (0, _TaskUtils.getIsConferenceInProgress)(taskData)) {
+        mainState = _constants.TaskState.CONFERENCING;
+      } else if (isMainHeld || taskData.interaction.state === 'hold') {
+        mainState = _constants.TaskState.HELD;
+      } else {
+        mainState = _constants.TaskState.CONNECTED;
+      }
+    }
+    return {
+      hasConsultLeg: false,
+      activeLeg: 'main',
+      mainState,
+      consultState: _constants.TaskState.CONSULTING
+    };
+  }
+  let mainState = _constants.TaskState.HELD;
+  if (currentState === _constants.TaskState.CONFERENCING) {
+    mainState = _constants.TaskState.CONFERENCING;
+  } else if (context.consultCallHeld) {
+    const mainMediaId = taskData?.interaction?.mainInteractionId || taskData?.interactionId;
+    const isMainHeld = Boolean(mainMediaId && taskData?.interaction?.media?.[mainMediaId]?.isHold === true);
+    mainState = isMainHeld || taskData?.interaction?.state === 'hold' ? _constants.TaskState.HELD : _constants.TaskState.CONNECTED;
+  } else if (currentState === _constants.TaskState.CONNECTED || currentState === _constants.TaskState.HELD) {
+    mainState = currentState;
+  }
+  return {
+    hasConsultLeg: true,
+    activeLeg: context.consultCallHeld ? 'main' : 'consult',
+    mainState,
+    consultState: isConsultingState ? currentState : _constants.TaskState.CONSULTING
+  };
+}
+function computeUIControls(currentState, context, fallbackTaskData) {
+  if (currentState === _constants.TaskState.TERMINATED || currentState === _constants.TaskState.COMPLETED) {
+    return getDefaultUIControls();
+  }
+  switch (context.uiControlConfig.channelType) {
+    case _types.TASK_CHANNEL_TYPE.VOICE:
+      {
+        const {
+          hasConsultLeg,
+          activeLeg,
+          mainState,
+          consultState
+        } = getVoiceLegState(currentState, context, context.uiControlConfig, fallbackTaskData);
+        const mainControls = computeVoiceInteractionUIControls(mainState, context, context.uiControlConfig, fallbackTaskData, 'main');
+        const consultControls = hasConsultLeg ? computeVoiceInteractionUIControls(consultState, context, context.uiControlConfig, fallbackTaskData, 'consult') : getDefaultInteractionUIControls();
+        return createTaskUIControls(mainControls, consultControls, activeLeg);
+      }
+    case _types.TASK_CHANNEL_TYPE.DIGITAL:
+      return createTaskUIControls(computeDigitalInteractionUIControls(currentState, context, fallbackTaskData), getDefaultInteractionUIControls(), 'main');
+    default:
+      return getDefaultUIControls();
+  }
+}
+function haveInteractionUIControlsChanged(previous, next) {
+  return Object.keys(next).some(key => {
+    const prev = previous[key];
+    const curr = next[key];
+    return prev.isVisible !== curr.isVisible || prev.isEnabled !== curr.isEnabled;
+  });
+}
+function haveUIControlsChanged(previous, next) {
+  if (!previous) return true;
+  return previous.activeLeg !== next.activeLeg || haveInteractionUIControlsChanged(previous.main, next.main) || haveInteractionUIControlsChanged(previous.consult, next.consult);
+}
+//# sourceMappingURL=uiControlsComputer.js.map