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

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/src/types.ts

@@ -846,6 +846,27 @@ export type UpdateDeviceTypeResponse = Agent.DeviceTypeUpdateSuccess | Error;
  */
 export type TranscriptAction = 'START' | 'STOP';
 
+/**
+ * Parameters used to request an AI Assistant suggested response.
+ * @public
+ * @example
+ * const params: SuggestedResponseParams = {
+ *   interactionId: 'interaction-123',
+ *   actionTimeStamp: Date.now(),
+ *   context: 'Need help with credit card payment due date',
+ * };
+ */
+export type SuggestedResponseParams = {
+  /** Agent identifier */
+  agentId: string;
+  /** Interaction identifier for which suggestion should be generated */
+  interactionId: string;
+  /** Optional additional context that should refine the suggestion */
+  context?: string;
+  /** Optional language code for suggestions (for example, 'en'). Defaults to 'en'. */
+  languageCode?: string;
+};
+
 /**
  * Supported AI Assistant event categories.
  * @public
@@ -879,6 +900,10 @@ export type AIAssistantEventType = Enum<typeof AIAssistantEventType>;
 export const AIAssistantEventName = {
   /** Request transcript streaming for an interaction */
   GET_TRANSCRIPTS: 'GET_TRANSCRIPTS',
+  /** Request a suggested response for an interaction */
+  GET_SUGGESTIONS: 'GET_SUGGESTIONS',
+  /** Add extra context to refine a suggested response */
+  ADD_SUGGESTIONS_EXTRA_CONTEXT: 'ADD_SUGGESTIONS_EXTRA_CONTEXT',
   /** Request mid-call summary generation */
   GET_MID_CALL_SUMMARY: 'GET_MID_CALL_SUMMARY',
   /** Request post-call summary generation */

package/test/unit/spec/cc.ts

@@ -110,8 +110,10 @@ describe('webex.cc', () => {
 
     mockApiAIAssistant = {
       sendEvent: jest.fn(),
+      getSuggestedResponse: jest.fn(),
       fetchHistoricTranscripts: jest.fn(),
       setAIFeatureFlags: jest.fn(),
+      setAgentId: jest.fn(),
     };
 
     // Mock Services instance

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

@@ -57,23 +57,18 @@ describe('ApiAIAssistant', () => {
       'START'
     );
 
-    expect(mockWebex.request).toHaveBeenCalledWith({
-      uri: 'https://api-ai-assistant.produs1.ciscoccservice.com/event',
-      method: HTTP_METHODS.POST,
-      addAuthHeader: true,
-      body: {
-        agentId: 'test-agent-id',
-        orgId: 'test-org-id',
-        eventType: 'CUSTOM_EVENT',
-        eventName: 'GET_TRANSCRIPTS',
-        eventDetails: {
-          data: expect.objectContaining({
-            interactionId: 'interaction-1',
-            action: 'START',
-          }),
-        },
-      },
-    });
+    expect(mockWebex.request).toHaveBeenCalledTimes(1);
+    const requestArgs = (mockWebex.request as jest.Mock).mock.calls[0][0];
+
+    expect(requestArgs.uri).toBe('https://api-ai-assistant.produs1.ciscoccservice.com/event');
+    expect(requestArgs.method).toBe(HTTP_METHODS.POST);
+    expect(requestArgs.addAuthHeader).toBe(true);
+    expect(requestArgs.body.agentId).toBe('test-agent-id');
+    expect(requestArgs.body.orgId).toBe('test-org-id');
+    expect(requestArgs.body.eventType).toBe('CUSTOM_EVENT');
+    expect(requestArgs.body.eventName).toBe('GET_TRANSCRIPTS');
+    expect(requestArgs.body.eventDetails.data.interactionId).toBe('interaction-1');
+    expect(requestArgs.body.eventDetails.data.action).toBe('START');
     expect(result).toEqual({ok: true});
   });
 
@@ -97,6 +92,83 @@ describe('ApiAIAssistant', () => {
     expect(result).toEqual(responseBody as any);
   });
 
+  it('should request suggested response without extra context using sendEvent', async () => {
+    const sendEventSpy = jest.spyOn(apiAIAssistant, 'sendEvent').mockResolvedValue({ok: true});
+    apiAIAssistant.setAIFeatureFlags({suggestedResponses: {enable: true}} as any);
+
+    const result = await apiAIAssistant.getSuggestedResponse({
+      agentId: 'test-agent-id',
+      interactionId: 'interaction-1',
+    });
+
+    expect(sendEventSpy).toHaveBeenCalledTimes(1);
+    const [agentId, interactionId, eventType, eventName, action, context, languageCode, trackingId] =
+      sendEventSpy.mock.calls[0];
+
+    expect(agentId).toBe('test-agent-id');
+    expect(interactionId).toBe('interaction-1');
+    expect(eventType).toBe('CUSTOM_EVENT');
+    expect(eventName).toBe('GET_SUGGESTIONS');
+    expect(action).toBeUndefined();
+    expect(context).toBeUndefined();
+    expect(languageCode).toBe('en');
+    expect(typeof trackingId).toBe('string');
+    expect(trackingId.startsWith('WX_CC_SDK_')).toBe(true);
+    expect(result).toEqual({ok: true});
+  });
+
+  it('should request suggested response with extra context using sendEvent', async () => {
+    const sendEventSpy = jest.spyOn(apiAIAssistant, 'sendEvent').mockResolvedValue({ok: true});
+    apiAIAssistant.setAIFeatureFlags({suggestedResponses: {enable: true}} as any);
+
+    const result = await apiAIAssistant.getSuggestedResponse({
+      agentId: 'test-agent-id',
+      interactionId: 'interaction-1',
+      context: 'Need assistance with credit card payment due date',
+    });
+
+    expect(sendEventSpy).toHaveBeenCalledTimes(1);
+    const [agentId, interactionId, eventType, eventName, action, context, languageCode, trackingId] =
+      sendEventSpy.mock.calls[0];
+
+    expect(agentId).toBe('test-agent-id');
+    expect(interactionId).toBe('interaction-1');
+    expect(eventType).toBe('CUSTOM_EVENT');
+    expect(eventName).toBe('ADD_SUGGESTIONS_EXTRA_CONTEXT');
+    expect(action).toBeUndefined();
+    expect(context).toBe('Need assistance with credit card payment due date');
+    expect(languageCode).toBe('en');
+    expect(typeof trackingId).toBe('string');
+    expect(trackingId.startsWith('WX_CC_SDK_')).toBe(true);
+    expect(result).toEqual({ok: true});
+  });
+
+  it('should treat whitespace-only context as GET_SUGGESTIONS', async () => {
+    const sendEventSpy = jest.spyOn(apiAIAssistant, 'sendEvent').mockResolvedValue({ok: true});
+    apiAIAssistant.setAIFeatureFlags({suggestedResponses: {enable: true}} as any);
+
+    const result = await apiAIAssistant.getSuggestedResponse({
+      agentId: 'test-agent-id',
+      interactionId: 'interaction-1',
+      context: '   ',
+    });
+
+    expect(sendEventSpy).toHaveBeenCalledTimes(1);
+    const [agentId, interactionId, eventType, eventName, action, context, languageCode, trackingId] =
+      sendEventSpy.mock.calls[0];
+
+    expect(agentId).toBe('test-agent-id');
+    expect(interactionId).toBe('interaction-1');
+    expect(eventType).toBe('CUSTOM_EVENT');
+    expect(eventName).toBe('GET_SUGGESTIONS');
+    expect(action).toBeUndefined();
+    expect(context).toBe('');
+    expect(languageCode).toBe('en');
+    expect(typeof trackingId).toBe('string');
+    expect(trackingId.startsWith('WX_CC_SDK_')).toBe(true);
+    expect(result).toEqual({ok: true});
+  });
+
   it('should fail when base URL mapping is not available', async () => {
     (mockWebex.internal.services.get as jest.Mock).mockReturnValue('https://unknown-host.invalid');
 
@@ -129,4 +201,20 @@ describe('ApiAIAssistant', () => {
 
     expect(errorMessage).toBe('Error while performing fetchHistoricTranscripts');
   });
+
+  it('should fail when suggested responses feature is disabled', async () => {
+    apiAIAssistant.setAIFeatureFlags({suggestedResponses: {enable: false}} as any);
+    let errorMessage = '';
+
+    try {
+      await apiAIAssistant.getSuggestedResponse({
+        agentId: 'test-agent-id',
+        interactionId: 'interaction-1',
+      });
+    } catch (error) {
+      errorMessage = (error as Error)?.message || '';
+    }
+
+    expect(errorMessage).toBe('Error while performing getSuggestedResponse');
+  });
 });

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/TaskManager.ts

@@ -253,6 +253,19 @@ describe('TaskManager', () => {
   });
 
   it('should invoke sendEvent for configured start/stop backend events', () => {
+    taskManager.setConfigFlags({
+      isEndTaskEnabled: true,
+      isEndConsultEnabled: true,
+      webRtcEnabled: true,
+      autoWrapup: false,
+      aiFeature: {
+        id: 'ai-feature-1',
+        realtimeTranscripts: {
+          enable: true,
+        },
+      },
+    });
+
     const interactionId = taskId;
     const message = (type: CC_EVENTS) =>
       JSON.stringify({
@@ -316,6 +329,35 @@ describe('TaskManager', () => {
     expect(mockApiAIAssistant.sendEvent).not.toHaveBeenCalled();
   });
 
+  it('should not invoke sendEvent when realtime transcripts config is missing', () => {
+    taskManager.setConfigFlags({
+      isEndTaskEnabled: true,
+      isEndConsultEnabled: true,
+      webRtcEnabled: true,
+      autoWrapup: false,
+      aiFeature: {
+        id: 'ai-feature-1',
+        suggestedResponses: {
+          enable: true,
+        },
+      },
+    });
+
+    const message = (type: CC_EVENTS) =>
+      JSON.stringify({
+        data: {
+          ...taskDataMock,
+          interactionId: taskId,
+          type,
+        },
+      });
+
+    webSocketManagerMock.emit('message', message(CC_EVENTS.AGENT_CONTACT_ASSIGNED));
+    webSocketManagerMock.emit('message', message(CC_EVENTS.AGENT_CONSULTING));
+
+    expect(mockApiAIAssistant.sendEvent).not.toHaveBeenCalled();
+  });
+
   it('should emit REAL_TIME_TRANSCRIPTION from RTD websocket payload', () => {
     const task = taskManager.getTask(taskId);
     const taskEmitSpy = jest.spyOn(task, 'emit');