@webex/contact-center 3.12.0-next.147 → 3.12.0-next.149

package/test/unit/spec/cc.ts

@@ -1,5 +1,8 @@
 import 'jsdom-global/register';
+import EventEmitter from 'events';
 import {
+  AIAssistantEventName,
+  AIAssistantEventType,
   BuddyAgents,
   BuddyAgentsResponse,
   LoginOption,
@@ -15,10 +18,14 @@ import type {ContactServiceQueuesResponse} from '../../../src/types';
 import MockWebex from '@webex/test-helper-mock-webex';
 import {StationLoginSuccess, AGENT_EVENTS} from '../../../src/services/agent/types';
 import {SetStateResponse} from '../../../src/types';
-import {AGENT, SUBSCRIBE_API, WEB_RTC_PREFIX} from '../../../src/services/constants';
+import {
+  AGENT,
+  SUBSCRIBE_API,
+  WEB_RTC_PREFIX,
+} from '../../../src/services/constants';
 import Services from '../../../src/services';
 import config from '../../../src/config';
-import {CC_EVENTS} from '../../../src/services/config/types';
+import {CC_TASK_EVENTS, CC_EVENTS} from '../../../src/services/config/types';
 import LoggerProxy from '../../../src/logger-proxy';
 import * as Utils from '../../../src/services/core/Utils';
 import {
@@ -33,11 +40,26 @@ import {
 import '../../../__mocks__/workerMock';
 import {Profile} from '../../../src/services/config/types';
 import TaskManager from '../../../src/services/task/TaskManager';
-import {AgentContact, TASK_EVENTS} from '../../../src/services/task/types';
+import Task from '../../../src/services/task/Task';
+import {
+  AgentContact,
+  AISummaryResponse,
+  TASK_CHANNEL_TYPE,
+  TASK_EVENTS,
+  TaskData,
+} from '../../../src/services/task/types';
+import {AI_SUMMARY_REQUEST_CANCELLED} from '../../../src/services/task/constants';
+import type {ApiAIAssistant} from '../../../src/services/ApiAiAssistant';
+import type {AIFeatureFlags} from '../../../src/types';
 import MetricsManager from '../../../src/metrics/MetricsManager';
 import {METRIC_EVENT_NAMES} from '../../../src/metrics/constants';
 import Mercury from '@webex/internal-plugin-mercury';
 import WebexRequest from '../../../src/services/core/WebexRequest';
+import {
+  createDeferred,
+  flushEventLoopTurn,
+  flushMicrotasks,
+} from '../fixtures/aiSummaryTestUtils';
 
 jest.mock('../../../src/logger-proxy', () => ({
   __esModule: true,
@@ -45,18 +67,306 @@ jest.mock('../../../src/logger-proxy', () => ({
     log: jest.fn(),
     error: jest.fn(),
     info: jest.fn(),
+    warn: jest.fn(),
     initialize: jest.fn(),
   },
 }));
 
+jest.mock('../../../src/services', () => ({
+  __esModule: true,
+  default: {
+    getInstance: jest.fn(() => ({
+      agent: {
+        stationLogin: jest.fn(),
+        logout: jest.fn(),
+        reload: jest.fn(),
+        stateChange: jest.fn(),
+        buddyAgents: jest.fn(),
+      },
+      config: {
+        getAgentConfig: jest.fn(),
+        getOutdialAniEntries: jest.fn(),
+      },
+      webSocketManager: {
+        initWebSocket: jest.fn(),
+        on: jest.fn(),
+        off: jest.fn(),
+        close: jest.fn(),
+        isSocketClosed: false,
+      },
+      rtdWebSocketManager: {
+        initWebSocket: jest.fn(),
+        on: jest.fn(),
+        off: jest.fn(),
+        close: jest.fn(),
+        isSocketClosed: false,
+      },
+      connectionService: {
+        on: jest.fn(),
+        off: jest.fn(),
+      },
+      contact: {},
+      dialer: {
+        startOutdial: jest.fn(),
+        acceptPreviewContact: jest.fn(),
+        skipPreviewContact: jest.fn(),
+        removePreviewContact: jest.fn(),
+      },
+    })),
+  },
+}));
+
+jest.mock('../../../src/services/task/TaskManager', () => ({
+  __esModule: true,
+  default: {
+    getTaskManager: jest.fn(() => ({
+      on: jest.fn(),
+      off: jest.fn(),
+      emit: jest.fn(),
+      setConfigFlags: jest.fn(),
+      setWrapupData: jest.fn(),
+      setAgentId: jest.fn(),
+      setAgentName: jest.fn(),
+      setWebRtcEnabled: jest.fn(),
+      setAnswerCallOnWebexService: jest.fn(),
+      registerIncomingCallEvent: jest.fn(),
+      registerTaskListeners: jest.fn(),
+      unregisterIncomingCallEvent: jest.fn(),
+      getTask: jest.fn(),
+      getActiveTasks: jest.fn(),
+      handleRealtimeWebsocketEvent: jest.fn(),
+      clearAISummaryState: jest.fn(),
+    })),
+  },
+}));
+
+jest.mock('../../../src/metrics/MetricsManager', () => ({
+  __esModule: true,
+  default: {
+    getInstance: jest.fn(),
+    getCommonTrackingFieldForAQMResponse: jest.fn(() => ({})),
+    getCommonTrackingFieldForAQMResponseFailed: jest.fn(() => ({})),
+  },
+}));
+
+jest.mock('../../../src/services/core/WebexRequest', () => ({
+  __esModule: true,
+  default: {
+    getInstance: jest.fn(() => ({
+      request: jest.fn(),
+      uploadLogs: jest.fn(),
+    })),
+  },
+}));
+
+jest.mock('../../../src/services/ApiAiAssistant', () => {
+  class MockApiAIAssistant {
+    public sendEvent = jest.fn();
+    public requestAndWaitForRtd = jest.fn();
+    public resolveFromRtdEvent = jest.fn();
+    public clearAllRtdRequests = jest.fn();
+    public getSuggestedResponse = jest.fn();
+    public fetchHistoricTranscripts = jest.fn();
+    public requestWellnessBreak = jest.fn();
+    public respondToWellnessBreak = jest.fn();
+    public setAIFeatureFlags = jest.fn();
+    public setAgentId = jest.fn();
+  }
+
+  return {
+    __esModule: true,
+    default: MockApiAIAssistant,
+    ApiAIAssistant: MockApiAIAssistant,
+  };
+});
+
+jest.mock('../../../src/services/WebCallingService', () => {
+  class MockWebCallingService {
+    public loginOption = 'AGENT_DN';
+    public registerWebCallingLine = jest.fn().mockResolvedValue(undefined);
+    public deregisterWebCallingLine = jest.fn().mockResolvedValue(undefined);
+    public setLoginOption = jest.fn((loginOption: string) => {
+      this.loginOption = loginOption;
+    });
+  }
+
+  return {
+    __esModule: true,
+    default: MockWebCallingService,
+  };
+});
+
+jest.mock('../../../src/services/task/TaskFactory', () => ({
+  __esModule: true,
+  default: {
+    createTask: jest.fn(),
+  },
+}));
+
+jest.mock('../../../src/services/task/voice/WebRTC', () => ({
+  __esModule: true,
+  default: class MockWebRTC {},
+}));
+
+jest.mock('../../../src/services/task/taskDataNormalizer', () => ({
+  normalizeTaskData: jest.fn((data) => data),
+}));
+
+jest.mock('../../../src/services/task/state-machine', () => ({
+  ...jest.requireActual('../../../src/services/task/state-machine'),
+  createTaskStateMachine: jest.fn(
+    jest.requireActual('../../../src/services/task/state-machine').createTaskStateMachine
+  ),
+}));
+
+jest.mock('../../../src/services/task/state-machine/uiControlsComputer', () => ({
+  computeUIControls: jest.fn(() => ({})),
+  getDefaultUIControls: jest.fn(() => ({})),
+  haveUIControlsChanged: jest.fn(() => false),
+}));
+
+jest.mock('../../../src/services/task/AutoWrapup', () => ({
+  __esModule: true,
+  default: class MockAutoWrapup {},
+}));
+
+jest.mock('../../../src/services/EntryPoint', () => {
+  class MockEntryPoint {
+    public getEntryPoints() {
+      return Promise.resolve({});
+    }
+  }
+
+  return {
+    __esModule: true,
+    default: MockEntryPoint,
+    EntryPoint: MockEntryPoint,
+  };
+});
+
+jest.mock('../../../src/services/AddressBook', () => {
+  class MockAddressBook {
+    public getEntries() {
+      return Promise.resolve({});
+    }
+  }
+
+  return {
+    __esModule: true,
+    default: MockAddressBook,
+    AddressBook: MockAddressBook,
+  };
+});
+
+jest.mock('../../../src/services/Queue', () => {
+  class MockQueue {
+    public getQueues() {
+      return Promise.resolve({});
+    }
+  }
+
+  return {
+    __esModule: true,
+    default: MockQueue,
+    Queue: MockQueue,
+  };
+});
+
 jest.mock('../../../src/services/config');
 jest.mock('../../../src/services/core/websocket/WebSocketManager');
 jest.mock('../../../src/services/core/websocket/connection-service');
-jest.mock('../../../src/services/WebCallingService');
 jest.mock('uuid', () => ({v4: () => 'mock-tracking-uuid'}));
 
 global.URL.createObjectURL = jest.fn(() => 'blob:http://localhost:3000/12345');
 
+class EventEmitterDouble extends EventEmitter {
+  public isSocketClosed = false;
+  public initWebSocket = jest.fn().mockResolvedValue({});
+  public close = jest.fn(() => {
+    this.isSocketClosed = true;
+  });
+  public mapCallToTask = jest.fn();
+
+  public on = jest.fn((eventName: string | symbol, listener: (...args: unknown[]) => void) => {
+    super.on(eventName, listener);
+
+    return this;
+  });
+
+  public off = jest.fn((eventName: string | symbol, listener: (...args: unknown[]) => void) => {
+    super.off(eventName, listener);
+
+    return this;
+  });
+}
+
+class AISummaryLifecycleTask extends Task {
+  public constructor(data: TaskData, apiAIAssistant?: ApiAIAssistant, agentId = 'agent-1') {
+    super(
+      {} as any,
+      data,
+      {
+        channelType: TASK_CHANNEL_TYPE.VOICE,
+        isEndTaskEnabled: true,
+        isEndConsultEnabled: true,
+      },
+      undefined,
+      agentId,
+      undefined,
+      apiAIAssistant
+    );
+  }
+
+  public accept() {
+    return Promise.resolve({} as any);
+  }
+}
+
+const createAISummaryLifecycleTask = (
+  data: TaskData = createAISummaryLifecycleTaskData(),
+  apiAIAssistant?: ApiAIAssistant
+): AISummaryLifecycleTask => new AISummaryLifecycleTask(data, apiAIAssistant);
+
+const createAISummaryLifecycleTaskData = (
+  overrides: Partial<TaskData> & {conversationId?: string} = {}
+): TaskData => {
+  const {
+    conversationId = 'conversation-1',
+    interaction: interactionOverrides,
+    ...taskOverrides
+  } = overrides;
+  const interactionId = taskOverrides.interactionId ?? 'interaction-1';
+
+  return {
+    mediaResourceId: 'media-resource-1',
+    eventType: CC_EVENTS.AGENT_CONTACT_ASSIGNED,
+    agentId: 'agent-1',
+    destAgentId: '',
+    trackingId: 'tracking-1',
+    consultMediaResourceId: '',
+    interactionId,
+    orgId: 'org-1',
+    owner: 'agent-1',
+    queueMgr: 'queue-manager-1',
+    type: 'telephony',
+    isConferencing: false,
+    taskId: 'task-owner-1',
+    ...taskOverrides,
+    interaction: {
+      interactionId,
+      mainInteractionId: conversationId,
+      mediaType: 'telephony',
+      media: {
+        [interactionId]: {
+          mediaResourceId: 'media-resource-1',
+        },
+      },
+      callProcessingDetails: {},
+      ...(interactionOverrides as Record<string, unknown> | undefined),
+    },
+  } as TaskData;
+};
+
 describe('webex.cc', () => {
   let webex;
   let mockApiAIAssistant;
@@ -169,6 +479,7 @@ describe('webex.cc', () => {
       setConfigFlags: jest.fn(),
       setWrapupData: jest.fn(),
       setAgentId: jest.fn(),
+      setAgentName: jest.fn(),
       setWebRtcEnabled: jest.fn(),
       setAnswerCallOnWebexService: jest.fn(),
       handleRealtimeWebsocketEvent: jest.fn(),
@@ -183,6 +494,8 @@ describe('webex.cc', () => {
       off: jest.fn(),
       emit: jest.fn(),
       unregisterIncomingCallEvent: jest.fn(),
+      handleRealtimeWebsocketEvent: jest.fn(),
+      clearAISummaryState: jest.fn(),
     };
 
     mockMetricsManager = {
@@ -206,6 +519,7 @@ describe('webex.cc', () => {
 
   afterEach(() => {
     jest.clearAllMocks();
+    jest.restoreAllMocks();
   });
 
   it('should initialize services and logger proxy on ready event', () => {
@@ -272,7 +586,7 @@ describe('webex.cc', () => {
   });
 
   describe('register', () => {
-    const mockAgentProfile: Profile = {
+    const createFreshAgentProfile = (overrides: Partial<Profile> = {}): Profile => ({
       agentId: 'agent123',
       agentMailId: '',
       agentName: 'John',
@@ -325,7 +639,10 @@ describe('webex.cc', () => {
       webRtcEnabled: true,
       lostConnectionRecoveryTimeout: 0,
       isWellnessBreakEnabled: false,
-    };
+      ...overrides,
+    });
+
+    const mockAgentProfile: Profile = createFreshAgentProfile();
 
     it('should register successfully and return agent profile', async () => {
       mockAgentProfile.aiFeature = {realtimeTranscripts: {enable: true}} as any;
@@ -376,7 +693,7 @@ describe('webex.cc', () => {
         resource: SUBSCRIBE_API,
       });
 
-      // TODO: https://jira-eng-gpk2.cisco.com/jira/browse/SPARK-626777 Implement the de-register method and close the listener there
+      // SPARK-626777 tracks moving listener cleanup into the future de-register API.
       expect(mockTaskManager.on).toHaveBeenCalledWith(
         TASK_EVENTS.TASK_INCOMING,
         expect.any(Function)
@@ -426,6 +743,7 @@ describe('webex.cc', () => {
           getWxAppUsersubPublished: expect.any(Function),
         })
       );
+      expect(mockTaskManager.clearAISummaryState).not.toHaveBeenCalled();
       expect(reloadSpy).toHaveBeenCalled();
       expect(result).toEqual({...mockAgentProfile, agentSessionId: 'session-after-refresh'});
       expect(mockMetricsManager.timeEvent).toHaveBeenCalledWith([
@@ -722,6 +1040,909 @@ describe('webex.cc', () => {
         expect.any(Function)
       );
     });
+
+    it('should connect RTD websocket when either generated summary organization flag is enabled', async () => {
+      jest.spyOn(webex.internal.mercury, 'connect').mockResolvedValue(true);
+      jest.spyOn(webex.cc.services.agent, 'reload').mockResolvedValue({
+        data: {
+          auxCodeId: 'auxCodeId',
+          agentId: 'agentId',
+          deviceType: LoginOption.EXTENSION,
+          dn: '12345',
+        },
+      });
+      mockWebSocketManager.initWebSocket.mockResolvedValue({agentId: 'agent123'});
+
+      for (const generatedSummaries of [
+        {wrapUpSummariesEnabled: true, consultTransferSummariesEnabled: false},
+        {wrapUpSummariesEnabled: false, consultTransferSummariesEnabled: true},
+      ]) {
+        jest.clearAllMocks();
+        jest.spyOn(webex.cc.services.config, 'getAgentConfig').mockResolvedValue({
+          ...mockAgentProfile,
+          aiFeature: {generatedSummaries} as any,
+        });
+
+        await webex.cc.register();
+
+        expect(webex.cc.services.rtdWebSocketManager.initWebSocket).toHaveBeenCalledWith({
+          body: {
+            force: true,
+            isKeepAliveEnabled: false,
+            clientType: 'WebexCCSDK',
+            allowMultiLogin: false,
+          },
+          resource: 'v1/realtime/subscribe',
+        });
+      }
+    });
+
+    it.each([
+      {
+        title: 'aiFeature is absent',
+        profileAgentId: 'profile-agent-without-ai-feature',
+        defaultDn: 'normalized-dn-without-ai-feature',
+        aiFeature: undefined,
+      },
+      {
+        title: 'aiFeature has no optional feature objects',
+        profileAgentId: 'profile-agent-with-empty-ai-feature',
+        defaultDn: 'normalized-dn-with-empty-ai-feature',
+        aiFeature: {} as any,
+      },
+    ])(
+      'should tolerate absent AI feature shapes without summary-driven RTD setup when $title',
+      async ({profileAgentId, defaultDn, aiFeature}) => {
+        const welcomeAgentId = 'welcome-agent-for-absent-ai-feature';
+        const configuredProfile = createFreshAgentProfile({
+          agentId: profileAgentId,
+          defaultDn,
+          dn: 'pre-register-dn',
+          webRtcEnabled: true,
+          aiFeature,
+        });
+        const expectedProfile = {...configuredProfile, dn: defaultDn};
+        webex.cc.$config = {...webex.cc.$config, allowAutomatedRelogin: false};
+        jest.spyOn(webex.internal.mercury, 'connect').mockResolvedValue(true);
+        const configSpy = jest
+          .spyOn(webex.cc.services.config, 'getAgentConfig')
+          .mockResolvedValue(configuredProfile);
+        mockWebSocketManager.initWebSocket.mockResolvedValue({agentId: welcomeAgentId});
+
+        await expect(webex.cc.register()).resolves.toEqual(expectedProfile);
+
+        expect(configSpy).toHaveBeenCalledWith('mockOrgId', welcomeAgentId);
+        expect(webex.cc.services.rtdWebSocketManager.initWebSocket).not.toHaveBeenCalled();
+      }
+    );
+
+    it.each([
+      {
+        title: 'all generated summary organization flags are disabled',
+        aiFeature: {
+          realtimeTranscripts: {enable: false},
+          suggestedResponses: {enable: false},
+          generatedSummaries: {
+            wrapUpSummariesEnabled: false,
+            consultTransferSummariesEnabled: false,
+          },
+        } as any,
+      },
+    ])(
+      'should keep registration operational without summary-driven RTD setup when $title',
+      async ({aiFeature}) => {
+        const welcomeAgentId = 'welcome-agent-with-disabled-summaries';
+        const configuredProfile = createFreshAgentProfile({
+          agentId: 'profile-agent-with-disabled-summaries',
+          defaultDn: 'normalized-dn-with-disabled-summaries',
+          dn: 'pre-register-dn',
+          webRtcEnabled: true,
+          aiFeature,
+        });
+        const expectedProfile = {...configuredProfile, dn: configuredProfile.defaultDn};
+        webex.cc.$config = {...webex.cc.$config, allowAutomatedRelogin: false};
+        const mercuryConnect = jest
+          .spyOn(webex.internal.mercury, 'connect')
+          .mockResolvedValue(true);
+        const setupEventListenersSpy = jest.spyOn(webex.cc, 'setupEventListeners');
+        const configSpy = jest
+          .spyOn(webex.cc.services.config, 'getAgentConfig')
+          .mockResolvedValue(configuredProfile);
+        mockWebSocketManager.initWebSocket.mockResolvedValue({agentId: welcomeAgentId});
+
+        const result = await webex.cc.register();
+
+        expect(mockWebSocketManager.initWebSocket).toHaveBeenCalledWith({
+          body: {
+            force: true,
+            isKeepAliveEnabled: false,
+            clientType: 'WebexCCSDK',
+            allowMultiLogin: false,
+          },
+          resource: SUBSCRIBE_API,
+        });
+        expect(configSpy).toHaveBeenCalledWith('mockOrgId', welcomeAgentId);
+        expect(setupEventListenersSpy).toHaveBeenCalled();
+        expect(mockTaskManager.on).toHaveBeenCalledWith(
+          TASK_EVENTS.TASK_INCOMING,
+          expect.any(Function)
+        );
+        expect(mockTaskManager.on).toHaveBeenCalledWith(
+          TASK_EVENTS.TASK_HYDRATE,
+          expect.any(Function)
+        );
+        expect(mockTaskManager.on).toHaveBeenCalledWith(
+          TASK_EVENTS.TASK_MULTI_LOGIN_HYDRATE,
+          expect.any(Function)
+        );
+        expect(mockWebSocketManager.on).toHaveBeenCalledWith('message', expect.any(Function));
+        expect(mockTaskManager.setConfigFlags).toHaveBeenCalledWith({
+          isEndTaskEnabled: configuredProfile.isEndTaskEnabled,
+          isEndConsultEnabled: configuredProfile.isEndConsultEnabled,
+          webRtcEnabled: configuredProfile.webRtcEnabled,
+          autoWrapup: configuredProfile.wrapUpData.wrapUpProps.autoWrapup ?? false,
+          aiFeature,
+          getWxAppUsersubPublished: expect.any(Function),
+          consultTransfer: {
+            allowConsultToQueue: configuredProfile.allowConsultToQueue,
+            accessQueue: configuredProfile.accessQueue,
+            accessEntryPoint: configuredProfile.accessEntryPoint,
+            accessBuddyTeam: configuredProfile.accessBuddyTeam,
+          },
+          enableWxBetterTogether: false,
+        });
+        expect(webex.cc.services.rtdWebSocketManager.initWebSocket).not.toHaveBeenCalled();
+        expect(webex.cc.services.rtdWebSocketManager.on).not.toHaveBeenCalledWith(
+          'message',
+          expect.any(Function)
+        );
+        expect(mercuryConnect).toHaveBeenCalled();
+        expect(result).toEqual(expectedProfile);
+      }
+    );
+  });
+
+  describe('AI summary lifecycle wiring', () => {
+    const sentinels = [
+      'summary-sentinel-cc-lifecycle',
+      'section-key-sentinel-cc-lifecycle',
+      'section-value-sentinel-cc-lifecycle',
+      'adaptive-card-sentinel-cc-lifecycle',
+      'agent-name-sentinel-cc-lifecycle',
+    ];
+
+    const createSummaryHarness = () => {
+      const ActualTaskManager = jest.requireActual('../../../src/services/task/TaskManager')
+        .default as typeof TaskManager;
+      const webSocketManager = new EventEmitterDouble();
+      const rtdWebSocketManager = new EventEmitterDouble();
+      const connectionService = new EventEmitterDouble();
+      const webCallingService = new EventEmitterDouble();
+      const transportDeferreds: Deferred<void>[] = [];
+      const pendingRequests = new Map<string, any>();
+      const apiAIAssistant: any = {
+        aiFeature: {
+          id: 'test-ai-feature',
+          generatedSummaries: {
+            wrapUpSummariesEnabled: true,
+            consultTransferSummariesEnabled: true,
+          },
+        },
+        getSuggestedResponse: jest.fn(),
+        fetchHistoricTranscripts: jest.fn(),
+        setAIFeatureFlags: jest.fn((flags: AIFeatureFlags) => {
+          apiAIAssistant.aiFeature = flags;
+        }),
+        setAgentId: jest.fn(),
+        pendingRequests,
+        sendEvent: jest.fn((_agentId: string, _interactionId: string, _eventType: string, eventName: string) => {
+          if (eventName.includes('SUMMARY_RESPONSE')) {
+            return Promise.resolve(undefined);
+          }
+
+          const deferred = createDeferred<void>();
+
+          transportDeferreds.push(deferred);
+
+          return deferred.promise;
+        }),
+      };
+      apiAIAssistant.requestAndWaitForRtd = jest.fn(async (options: any) => {
+        const publishTimestamp = Date.now();
+        let resolveResult: (payload: any) => void = () => undefined;
+        let rejectResult: (error: Error) => void = () => undefined;
+        const result = new Promise((resolve, reject) => {
+          resolveResult = resolve;
+          rejectResult = reject;
+        });
+        const key = JSON.stringify([options.rtdEventType, options.correlationId]);
+        pendingRequests.set(key, {
+          eventType: options.rtdEventType,
+          correlationId: options.correlationId,
+          resolve: resolveResult,
+          reject: rejectResult,
+          result,
+        });
+        try {
+          const acknowledgement = apiAIAssistant.sendEvent(
+            options.agentId,
+            options.interactionId,
+            options.eventType,
+            options.eventName,
+            options.eventMetaData,
+            undefined,
+            undefined,
+            publishTimestamp,
+            options.timeout
+          );
+          const [payload] = await Promise.all([result, acknowledgement]);
+          pendingRequests.delete(key);
+          return payload;
+        } catch (error) {
+          pendingRequests.delete(key);
+          throw error;
+        }
+      });
+      apiAIAssistant.resolveFromRtdEvent = jest.fn(
+        (eventType: string, correlationId: string, payload: any) => {
+          const key = JSON.stringify([eventType, correlationId]);
+          const request = pendingRequests.get(key);
+          if (!request) return 'not-found';
+          pendingRequests.delete(key);
+          request.resolve(payload);
+          return 'resolved';
+        }
+      );
+      apiAIAssistant.clearAllRtdRequests = jest.fn(() => {
+        pendingRequests.forEach((request) => {
+          const error = new Error(AI_SUMMARY_REQUEST_CANCELLED) as Error & {
+            data?: Record<string, unknown>;
+          };
+          error.data = {errorCode: AI_SUMMARY_REQUEST_CANCELLED};
+          request.reject(error);
+        });
+        pendingRequests.clear();
+      });
+      const taskManager = new ActualTaskManager(
+        apiAIAssistant as any,
+        mockContact,
+        webCallingService as any,
+        webSocketManager as any,
+        rtdWebSocketManager as any
+      );
+      const taskFactory = jest.requireMock('../../../src/services/task/TaskFactory')
+        .default as {createTask: jest.Mock};
+
+      taskFactory.createTask.mockImplementation(
+        (
+          _contact,
+          _webCallingService,
+          taskData: TaskData,
+          _configFlags,
+          _wrapupData,
+          _agentId,
+          _agentName,
+          _answerCallService,
+          taskApiAIAssistant: ApiAIAssistant
+        ) => createAISummaryLifecycleTask(taskData, taskApiAIAssistant)
+      );
+      const task = createAISummaryLifecycleTask(undefined, apiAIAssistant);
+
+      taskManager.setConfigFlags({
+        isEndTaskEnabled: true,
+        isEndConsultEnabled: true,
+        webRtcEnabled: false,
+        autoWrapup: false,
+        aiFeature: {
+          generatedSummaries: {
+            wrapUpSummariesEnabled: true,
+            consultTransferSummariesEnabled: true,
+          },
+        },
+      } as any);
+      taskManager.setAgentId('agent-1');
+      taskManager.setWebRtcEnabled(false);
+      (taskManager as any).taskCollection[task.data.interactionId] = task;
+
+      (webex.cc as any).taskManager = taskManager;
+      webex.cc.apiAIAssistant = apiAIAssistant as any;
+      webex.cc.services.webSocketManager = webSocketManager as any;
+      webex.cc.services.rtdWebSocketManager = rtdWebSocketManager as any;
+      webex.cc.services.connectionService = connectionService as any;
+
+      const emitRtdFrame = (type: string, data: Record<string, unknown>) => {
+        rtdWebSocketManager.emit('message', JSON.stringify({type, data: {data}}));
+      };
+      const dispatchRtdFrame = (type: string, data: Record<string, unknown>) => {
+        webex.cc['handleRTDWebsocketMessage'](JSON.stringify({type, data: {data}}));
+      };
+      const getApiAIAssistant = () => apiAIAssistant as any;
+      const getSummaryMapCounts = () => {
+        const api = getApiAIAssistant() as any;
+        const manager = taskManager as any;
+        const pendingRequests = Array.from(api.pendingRequests.values());
+
+        return {
+          pendingPostCall: pendingRequests.filter(
+            (request: any) => request.eventType === 'POST_CALL_SUMMARY'
+          ).length,
+          pendingMidCall: pendingRequests.filter(
+            (request: any) => request.eventType === 'MID_CALL_SUMMARY'
+          ).length,
+          receiving: manager.receivingSummaryBuffer.size,
+          featureEnablement: manager.pendingFeatureEnablement.size,
+        };
+      };
+      const expectSummaryStateCleared = () => {
+        expect(getSummaryMapCounts()).toEqual({
+          pendingPostCall: 0,
+          pendingMidCall: 0,
+          receiving: 0,
+          featureEnablement: 0,
+        });
+      };
+
+      return {
+        apiAIAssistant,
+        connectionService,
+        dispatchRtdFrame,
+        emitRtdFrame,
+        expectSummaryStateCleared,
+        getApiAIAssistant,
+        getSummaryMapCounts,
+        rtdWebSocketManager,
+        task,
+        taskManager,
+        transportDeferreds,
+        webSocketManager,
+      };
+    };
+
+    const attachRtdMessageListener = (rtdWebSocketManager: EventEmitterDouble) => {
+      rtdWebSocketManager.on('message', webex.cc['handleRTDWebsocketMessage']);
+    };
+
+    const countAISummaryRequestFinalMetrics = () =>
+      mockMetricsManager.trackEvent.mock.calls.filter(([eventName]) =>
+        [
+          METRIC_EVENT_NAMES.AI_SUMMARY_GET_POST_CALL_SUCCESS,
+          METRIC_EVENT_NAMES.AI_SUMMARY_GET_POST_CALL_FAILED,
+          METRIC_EVENT_NAMES.AI_SUMMARY_GET_MID_CALL_SUCCESS,
+          METRIC_EVENT_NAMES.AI_SUMMARY_GET_MID_CALL_FAILED,
+        ].includes(eventName)
+      ).length;
+
+    const expectSentinelsNotObserved = () => {
+      const observedArguments = JSON.stringify([
+        LoggerProxy.log.mock.calls,
+        LoggerProxy.info.mock.calls,
+        LoggerProxy.warn.mock.calls,
+        LoggerProxy.error.mock.calls,
+        mockMetricsManager.trackEvent.mock.calls,
+        mockMetricsManager.timeEvent.mock.calls,
+      ]);
+
+      sentinels.forEach((sentinel) => {
+        expect(observedArguments).not.toContain(sentinel);
+      });
+    };
+
+    const emitFeatureEnablement = (
+      harness: ReturnType<typeof createSummaryHarness>,
+      payload = {
+        interactionId: 'interaction-1',
+        postCallEnabled: true,
+        midCallEnabled: true,
+        actionTimestamp: 1,
+      }
+    ) => {
+      harness.emitRtdFrame(CC_TASK_EVENTS.FEATURE_ENABLEMENT, payload);
+    };
+
+    const dispatchFeatureEnablement = (
+      harness: ReturnType<typeof createSummaryHarness>,
+      payload = {
+        interactionId: 'interaction-1',
+        postCallEnabled: true,
+        midCallEnabled: true,
+        actionTimestamp: 1,
+      }
+    ) => {
+      harness.dispatchRtdFrame(CC_TASK_EVENTS.FEATURE_ENABLEMENT, payload);
+    };
+
+    const emitTaskLifecycleEvent = (
+      harness: ReturnType<typeof createSummaryHarness>,
+      eventType: CC_EVENTS,
+      overrides: Partial<TaskData> & {conversationId?: string}
+    ) => {
+      const interactionId = overrides.interactionId ?? 'interaction-1';
+
+      harness.webSocketManager.emit(
+        'message',
+        JSON.stringify({
+          data: {
+            ...createAISummaryLifecycleTaskData({
+              mediaResourceId: interactionId,
+              taskId: `task-owner-${interactionId}`,
+              ...overrides,
+            }),
+            type: eventType,
+          },
+        })
+      );
+    };
+
+    const emitSentinelPostCallSummary = (
+      harness: ReturnType<typeof createSummaryHarness>,
+      conversationId = 'conversation-1'
+    ) => {
+      harness.emitRtdFrame(CC_TASK_EVENTS.POST_CALL_SUMMARY, {
+        conversationId,
+        summaryText: sentinels[0],
+        sections: {
+          [sentinels[1]]: sentinels[2],
+          initialContactReason: sentinels[2],
+        },
+        adaptiveCard: {
+          body: [{text: sentinels[3]}],
+        },
+      });
+    };
+
+    const dispatchSentinelPostCallSummary = (
+      harness: ReturnType<typeof createSummaryHarness>,
+      conversationId = 'conversation-1'
+    ) => {
+      harness.dispatchRtdFrame(CC_TASK_EVENTS.POST_CALL_SUMMARY, {
+        conversationId,
+        summaryText: sentinels[0],
+        sections: {
+          [sentinels[1]]: sentinels[2],
+          initialContactReason: sentinels[2],
+        },
+        adaptiveCard: {
+          body: [{text: sentinels[3]}],
+        },
+      });
+    };
+
+    const emitSentinelMidCallSummary = (
+      harness: ReturnType<typeof createSummaryHarness>,
+      conversationId = 'conversation-1'
+    ) => {
+      harness.emitRtdFrame(CC_TASK_EVENTS.MID_CALL_SUMMARY, {
+        conversationId,
+        summaryText: sentinels[0],
+        agentName: sentinels[4],
+        sections: {
+          [sentinels[1]]: sentinels[2],
+          reasonForTransferOrConsult: sentinels[2],
+        },
+        adaptiveCard: {
+          body: [{text: sentinels[3]}],
+        },
+      });
+    };
+
+    afterEach(() => {
+      jest.useRealTimers();
+    });
+
+    it('forwards task-manager handlers through ContactCenter trigger and delegates RTD messages', () => {
+      const triggerSpy = jest.spyOn(webex.cc, 'trigger');
+      const task = {data: {interactionId: 'interaction-1'}} as any;
+
+      webex.cc['handleTaskHydrate'](task);
+      webex.cc['handleTaskMultiLoginHydrate'](task);
+      webex.cc['handleTaskMerged'](task);
+      webex.cc['handleCampaignPreviewReservation'](task);
+      webex.cc['handleRTDWebsocketMessage']('summary-frame');
+
+      expect(triggerSpy).toHaveBeenCalledWith(TASK_EVENTS.TASK_HYDRATE, task);
+      expect(triggerSpy).toHaveBeenCalledWith(TASK_EVENTS.TASK_MULTI_LOGIN_HYDRATE, task);
+      expect(triggerSpy).toHaveBeenCalledWith(TASK_EVENTS.TASK_MERGED, task);
+      expect(triggerSpy).toHaveBeenCalledWith(TASK_EVENTS.TASK_CAMPAIGN_PREVIEW_RESERVATION, task);
+      expect(mockTaskManager.handleRealtimeWebsocketEvent).toHaveBeenCalledWith('summary-frame');
+    });
+
+    it('clears active summary state on deregister', async () => {
+      jest.useFakeTimers();
+
+      const harness = createSummaryHarness();
+      const triggerSpy = jest.spyOn(webex.cc, 'trigger');
+      const profile = {
+        agentId: 'agent-1',
+        webRtcEnabled: false,
+        loginVoiceOptions: [LoginOption.EXTENSION],
+        isEndTaskEnabled: true,
+        isEndConsultEnabled: true,
+        wrapUpData: {wrapUpProps: {autoWrapup: false}},
+        aiFeature: {
+          generatedSummaries: {
+            wrapUpSummariesEnabled: true,
+            consultTransferSummariesEnabled: true,
+          },
+        },
+      } as any;
+
+      webex.cc.$config = {...webex.cc.$config, allowAutomatedRelogin: false};
+      harness.webSocketManager.initWebSocket.mockResolvedValue({agentId: 'agent-1'});
+      jest.spyOn(webex.cc.services.config, 'getAgentConfig').mockResolvedValue(profile);
+
+      await webex.cc.register();
+      await flushMicrotasks();
+
+      expect(harness.rtdWebSocketManager.listenerCount('message')).toBe(1);
+
+      dispatchFeatureEnablement(harness);
+      expect(harness.task.aiSummaryCapabilities).toEqual({
+        midCallEnabled: true,
+        postCallEnabled: true,
+      });
+
+      dispatchFeatureEnablement(harness, {
+        interactionId: 'orphan-before-deregister',
+        postCallEnabled: true,
+        midCallEnabled: true,
+        actionTimestamp: 4,
+      });
+      harness.dispatchRtdFrame(CC_TASK_EVENTS.MID_CALL_SUMMARY_RESPONSE_SUBSEQUENT_AGENT, {
+        conversationId: 'queued-before-deregister',
+        summaryText: sentinels[0],
+      });
+      expect(jest.getTimerCount()).toBe(0);
+      expect(harness.task.aiSummaryCapabilities).toEqual({
+        midCallEnabled: true,
+        postCallEnabled: true,
+      });
+      expect(harness.getSummaryMapCounts()).toEqual({
+        pendingPostCall: 0,
+        pendingMidCall: 0,
+        receiving: 1,
+        featureEnablement: 1,
+      });
+      expect(jest.getTimerCount()).toBe(0);
+
+      await webex.cc.deregister();
+
+      harness.expectSummaryStateCleared();
+      expect(harness.task.aiSummaryCapabilities).toEqual({
+        midCallEnabled: false,
+        postCallEnabled: false,
+      });
+      expect(jest.getTimerCount()).toBe(0);
+      expect(harness.rtdWebSocketManager.listenerCount('message')).toBe(0);
+      triggerSpy.mockClear();
+
+      dispatchSentinelPostCallSummary(harness, 'queued-after-deregister');
+
+      expect(harness.getSummaryMapCounts()).toEqual({
+        pendingPostCall: 0,
+        pendingMidCall: 0,
+        receiving: 0,
+        featureEnablement: 0,
+      });
+      expect(triggerSpy).not.toHaveBeenCalled();
+      expectSentinelsNotObserved();
+    });
+
+    it('flushes a buffered receiving summary through real TaskManager task publication once the task is answered', () => {
+      jest.useFakeTimers();
+
+      const harness = createSummaryHarness();
+      const interactionId = 'receiver-arrival-interaction';
+      const conversationId = interactionId;
+      const receivingPayload = {
+        conversationId,
+        summaryText: sentinels[0],
+        adaptiveCard: {body: [{text: sentinels[3]}]},
+      };
+      const receiverHandler = jest.fn();
+      const observedOrder: string[] = [];
+      let publishedTask: Task | undefined;
+      let receiverEmitSpy: jest.SpyInstance | undefined;
+
+      harness.dispatchRtdFrame(CC_TASK_EVENTS.MID_CALL_SUMMARY_RESPONSE_SUBSEQUENT_AGENT, {
+        ...receivingPayload,
+      });
+
+      expect(harness.getSummaryMapCounts()).toEqual({
+        pendingPostCall: 0,
+        pendingMidCall: 0,
+        receiving: 1,
+        featureEnablement: 0,
+      });
+      expect(jest.getTimerCount()).toBe(0);
+
+      harness.taskManager.on(TASK_EVENTS.TASK_INCOMING, (task: Task) => {
+        publishedTask = task;
+        receiverEmitSpy = jest.spyOn(task, 'emit');
+        task.on(TASK_EVENTS.TASK_ASSIGNED, () => observedOrder.push('answered'));
+        task.on(TASK_EVENTS.TASK_MID_CALL_SUMMARY_RECEIVED, (payload) => {
+          observedOrder.push('receiver-summary');
+          receiverHandler(payload);
+        });
+      });
+
+      emitTaskLifecycleEvent(harness, CC_EVENTS.AGENT_CONTACT_RESERVED, {
+        interactionId,
+        conversationId,
+      });
+
+      expect(publishedTask).toBe(harness.taskManager.getTask(interactionId));
+      expect(publishedTask).toBeInstanceOf(Task);
+      expect(receiverHandler).not.toHaveBeenCalled();
+      expect(harness.getSummaryMapCounts().receiving).toBe(1);
+
+      emitTaskLifecycleEvent(harness, CC_EVENTS.AGENT_CONTACT_ASSIGNED, {
+        interactionId,
+        conversationId,
+      });
+
+      expect(observedOrder).toEqual(['answered', 'receiver-summary']);
+      expect(receiverHandler).toHaveBeenCalledTimes(1);
+      expect(receiverHandler).toHaveBeenCalledWith(receivingPayload);
+      expect(
+        receiverEmitSpy?.mock.calls.filter(
+          ([eventName]) => eventName === TASK_EVENTS.TASK_MID_CALL_SUMMARY_RECEIVED
+        )
+      ).toHaveLength(1);
+      expect(harness.getSummaryMapCounts()).toEqual({
+        pendingPostCall: 0,
+        pendingMidCall: 0,
+        receiving: 0,
+        featureEnablement: 0,
+      });
+      expect(jest.getTimerCount()).toBe(0);
+      expectSentinelsNotObserved();
+    });
+
+    it('resolves a real post-call request through RTD and keeps summary sentinels out of metrics', async () => {
+      jest.useFakeTimers();
+
+      const harness = createSummaryHarness();
+
+      attachRtdMessageListener(harness.rtdWebSocketManager);
+      emitFeatureEnablement(harness);
+      jest.clearAllMocks();
+
+      const postCallRequest = harness.task.requestPostCallSummary();
+
+      await flushMicrotasks();
+      expect(harness.apiAIAssistant.sendEvent).toHaveBeenCalledWith(
+        'agent-1',
+        'interaction-1',
+        AIAssistantEventType.CTI_EVENT,
+        AIAssistantEventName.GET_POST_CALL_SUMMARY,
+        expect.objectContaining({conversationId: 'conversation-1'}),
+        undefined,
+        undefined,
+        expect.any(Number),
+        15000
+      );
+      emitSentinelPostCallSummary(harness);
+      harness.transportDeferreds[0].resolve(undefined);
+
+      await expect(postCallRequest).resolves.toMatchObject({
+        conversationId: 'conversation-1',
+        summaryText: sentinels[0],
+      });
+      expect(harness.getSummaryMapCounts()).toEqual({
+        pendingPostCall: 0,
+        pendingMidCall: 0,
+        receiving: 0,
+        featureEnablement: 0,
+      });
+      expect(jest.getTimerCount()).toBe(0);
+      expect(mockMetricsManager.trackEvent).toHaveBeenCalledWith(
+        METRIC_EVENT_NAMES.AI_SUMMARY_GET_POST_CALL_SUCCESS,
+        expect.objectContaining({
+          conversationId: 'conversation-1',
+          interactionId: 'interaction-1',
+        }),
+        ['operational']
+      );
+      harness.taskManager.clearAISummaryState();
+      harness.expectSummaryStateCleared();
+      expectSentinelsNotObserved();
+    });
+
+    it('sends post-call responses using current task data after manager cleanup', async () => {
+      jest.useFakeTimers();
+
+      const harness = createSummaryHarness();
+      const interactionId = 'post-call-cleanup-interaction';
+      const conversationId = 'post-call-cleanup-conversation';
+      const apiAIAssistant = harness.getApiAIAssistant();
+      let applicationTask: Task | undefined;
+
+      harness.taskManager.on(TASK_EVENTS.TASK_INCOMING, (task: Task) => {
+        if (task.data.interactionId === interactionId) {
+          applicationTask = task;
+        }
+      });
+      emitTaskLifecycleEvent(harness, CC_EVENTS.AGENT_CONTACT_RESERVED, {
+        interactionId,
+        conversationId,
+      });
+      emitTaskLifecycleEvent(harness, CC_EVENTS.AGENT_CONTACT_ASSIGNED, {
+        interactionId,
+        conversationId,
+      });
+
+      expect(applicationTask).toBe(harness.taskManager.getTask(interactionId));
+      const retainedTask = applicationTask as Task;
+
+      dispatchFeatureEnablement(harness, {
+        interactionId,
+        postCallEnabled: true,
+        midCallEnabled: true,
+        actionTimestamp: 9,
+      });
+
+      const postCallRequest = retainedTask.requestPostCallSummary();
+
+      await flushMicrotasks();
+      expect(postCallRequest).toBeDefined();
+      expect(harness.apiAIAssistant.sendEvent).toHaveBeenCalledWith(
+        'agent-1',
+        interactionId,
+        AIAssistantEventType.CTI_EVENT,
+        AIAssistantEventName.GET_POST_CALL_SUMMARY,
+        expect.objectContaining({conversationId}),
+        undefined,
+        undefined,
+        expect.any(Number),
+        15000
+      );
+      harness.dispatchRtdFrame(CC_TASK_EVENTS.POST_CALL_SUMMARY, {
+        conversationId,
+        summaryText: sentinels[0],
+      });
+      harness.transportDeferreds[0].resolve(undefined);
+
+      await expect(postCallRequest).resolves.toMatchObject({
+        conversationId,
+        summaryText: sentinels[0],
+      });
+      expect(harness.getSummaryMapCounts()).toEqual({
+        pendingPostCall: 0,
+        pendingMidCall: 0,
+        receiving: 0,
+        featureEnablement: 0,
+      });
+
+      emitTaskLifecycleEvent(harness, CC_EVENTS.AGENT_WRAPUP, {
+        interactionId,
+        conversationId,
+      });
+      emitTaskLifecycleEvent(harness, CC_EVENTS.AGENT_WRAPPEDUP, {
+        interactionId,
+        conversationId,
+      });
+
+      expect(harness.taskManager.getTask(interactionId)).toBeUndefined();
+      expect(harness.getSummaryMapCounts()).toEqual({
+        pendingPostCall: 0,
+        pendingMidCall: 0,
+        receiving: 0,
+        featureEnablement: 0,
+      });
+      expect(jest.getTimerCount()).toBe(0);
+
+      const requestCallsAfterRemoval = (apiAIAssistant as any).pendingRequests.size;
+      const responseInteractionId = 'post-call-response-current-interaction';
+      const responseConversationId = 'post-call-response-current-conversation';
+
+      retainedTask.updateTaskData(
+        createAISummaryLifecycleTaskData({
+          interactionId: responseInteractionId,
+          conversationId: responseConversationId,
+        }),
+        true
+      );
+
+      const responsePayload: AISummaryResponse = {
+        summary: {initialContactReason: 'resolved'},
+        feedback: 'thumbs_up',
+        state: 'DEFAULT',
+        wrapUpCode: 'resolved',
+        numberOfTimesViewed: 1,
+        numberOfTimesEdited: 0,
+        numberOfTimesCopied: 0,
+      };
+
+      await expect(
+        retainedTask.sendPostCallSummaryResponse(responsePayload)
+      ).resolves.toBeUndefined();
+
+      expect((apiAIAssistant as any).pendingRequests.size).toBe(requestCallsAfterRemoval);
+      expect(harness.apiAIAssistant.sendEvent).toHaveBeenCalledTimes(2);
+      expect(harness.apiAIAssistant.sendEvent).toHaveBeenNthCalledWith(
+        2,
+        'agent-1',
+        responseInteractionId,
+        AIAssistantEventType.CTI_EVENT,
+        AIAssistantEventName.POST_CALL_SUMMARY_RESPONSE,
+        {
+          conversationId: responseConversationId,
+          clientType: 'WxCC',
+          action: AIAssistantEventName.POST_CALL_SUMMARY_RESPONSE,
+          summary: {initialContactReason: 'resolved'},
+          feedback: 'thumbs_up',
+          wrapUpCode: 'resolved',
+          numberOfTimesViewed: 1,
+          numberOfTimesEdited: 0,
+          numberOfTimesCopied: 0,
+          state: 'DEFAULT',
+        },
+        undefined,
+        undefined,
+        expect.any(Number),
+        15000
+      );
+    });
+
+    it('cancels pending real public requests on deregister and ignores late HTTP settlement', async () => {
+      const harness = createSummaryHarness();
+      const unhandledRejections: unknown[] = [];
+      const unhandledRejectionListener = jest.fn((reason) => {
+        unhandledRejections.push(reason);
+      });
+
+      attachRtdMessageListener(harness.rtdWebSocketManager);
+      emitFeatureEnablement(harness);
+      jest.clearAllMocks();
+
+      webex.cc.agentConfig = {
+        agentId: 'agent-1',
+        webRtcEnabled: false,
+        loginVoiceOptions: [LoginOption.EXTENSION],
+      };
+
+      process.on('unhandledRejection', unhandledRejectionListener);
+      try {
+        const postCallRequest = harness.task.requestPostCallSummary();
+        const midCallRequest = harness.task.requestMidCallSummary('CONSULT');
+        postCallRequest.catch(() => undefined);
+        midCallRequest.catch(() => undefined);
+
+        await flushMicrotasks();
+        expect(harness.transportDeferreds).toHaveLength(2);
+
+        await webex.cc.deregister();
+        await flushEventLoopTurn();
+
+        expect(unhandledRejectionListener).not.toHaveBeenCalled();
+        expect(unhandledRejections).toHaveLength(0);
+        await expect(postCallRequest).rejects.toMatchObject({
+          message: AI_SUMMARY_REQUEST_CANCELLED,
+          data: {errorCode: AI_SUMMARY_REQUEST_CANCELLED},
+        });
+        await expect(midCallRequest).rejects.toMatchObject({
+          message: AI_SUMMARY_REQUEST_CANCELLED,
+          data: {errorCode: AI_SUMMARY_REQUEST_CANCELLED},
+        });
+        harness.expectSummaryStateCleared();
+
+        const finalMetricCountAfterCancellation = countAISummaryRequestFinalMetrics();
+
+        dispatchSentinelPostCallSummary(harness, 'queued-after-deregister');
+        harness.transportDeferreds[0].resolve(undefined);
+        harness.transportDeferreds[1].reject(new Error('late-http-rejected-after-deregister'));
+        await flushEventLoopTurn();
+
+        expect(unhandledRejectionListener).not.toHaveBeenCalled();
+        expect(unhandledRejections).toHaveLength(0);
+        expect(countAISummaryRequestFinalMetrics()).toBe(finalMetricCountAfterCancellation);
+        harness.expectSummaryStateCleared();
+        expectSentinelsNotObserved();
+      } finally {
+        process.off('unhandledRejection', unhandledRejectionListener);
+        harness.taskManager.clearAISummaryState();
+      }
+    });
   });
 
   describe('stationLogin', () => {
@@ -1861,7 +3082,7 @@ describe('webex.cc', () => {
       });
 
       expect(stationLogoutMock).toHaveBeenCalledWith({data: data});
-      // TODO: https://jira-eng-gpk2.cisco.com/jira/browse/SPARK-626777 Implement the de-register method and close the listener there
+      // SPARK-626777 tracks moving listener cleanup into the future de-register API.
       // expect(mockTaskManager.unregisterIncomingCallEvent).toHaveBeenCalledWith();
       // expect(mockTaskManager.off).toHaveBeenCalledWith(
       //   TASK_EVENTS.TASK_INCOMING,
@@ -2662,8 +3883,6 @@ describe('webex.cc', () => {
       );
 
       const setLoginOptionSpy = jest.spyOn(webex.cc.webCallingService, 'setLoginOption');
-      const incomingTaskListenerSpy = jest.spyOn(webex.cc, 'incomingTaskListener');
-      const webSocketManagerOnSpy = jest.spyOn(webex.cc.services.webSocketManager, 'on');
       await webex.cc['silentRelogin']();
 
       expect(LoggerProxy.log).toHaveBeenCalledWith('Starting silent relogin process', {
@@ -2694,8 +3913,8 @@ describe('webex.cc', () => {
       expect(webex.cc.agentConfig.deviceType).toBe(LoginOption.BROWSER);
       expect(registerWebCallingLineSpy).toHaveBeenCalled();
       expect(setLoginOptionSpy).toHaveBeenCalledWith(LoginOption.BROWSER);
-      // TODO: https://jira-eng-gpk2.cisco.com/jira/browse/SPARK-626777 Implement the de-register method and close the listener there
-      // expect(incomingTaskListenerSpy).toHaveBeenCalled();
+      // SPARK-626777 tracks moving listener cleanup into the future de-register API.
+      // expect(eventForwarderRefreshSpy).toHaveBeenCalled();
       // expect(webSocketManagerOnSpy).toHaveBeenCalledWith('message', expect.any(Function));
       // expect(mockTaskManager.on).toHaveBeenCalledWith(
       //   TASK_EVENTS.TASK_HYDRATE,
@@ -3030,6 +4249,9 @@ describe('webex.cc', () => {
         {module: CC_FILE, method: `startOutdial`, trackingId: error.details.trackingId}
       );
       expect(getErrorDetailsSpy).toHaveBeenCalledWith(error, 'startOutdial', CC_FILE);
+      expect(mockWebexRequest.uploadLogs).toHaveBeenCalledWith({
+        correlationId: error.details.trackingId,
+      });
     });
   });
 
@@ -3124,6 +4346,13 @@ describe('webex.cc', () => {
       deviceUnregisterSpy = jest.spyOn(webex.internal.device, 'unregister');
     });
 
+    afterEach(() => {
+      mockTaskManager.off.mockImplementation(() => undefined);
+      mockTaskManager.clearAISummaryState.mockImplementation(() => undefined);
+      mockRTDWebSocketManager.off.mockImplementation(() => undefined);
+      mockRTDWebSocketManager.close.mockImplementation(() => undefined);
+    });
+
     it('invalidates wellness context before deregistration cleanup can fail', async () => {
       const cleanupError = new Error('cleanup failed');
       let rejectCleanup: (error: Error) => void = () => undefined;
@@ -3136,6 +4365,9 @@ describe('webex.cc', () => {
       };
       webex.cc['updateWellnessSession']('session-1');
       jest.spyOn(webex.cc as any, 'teardownWxAppLocalState').mockReturnValue(cleanup);
+      webex.cc.apiAIAssistant.requestWellnessBreak.mockRejectedValue(
+        new Error('WELLNESS_BREAK_AGENT_SESSION_REQUIRED')
+      );
 
       const deregistration = webex.cc.deregister();
       const rejection = expect(deregistration).rejects.toThrow(cleanupError);
@@ -3195,10 +4427,17 @@ describe('webex.cc', () => {
       );
 
       expect(mockWebSocketManager.close).toHaveBeenCalledWith(false, 'Unregistering the SDK');
-      expect(webex.cc.services.rtdWebSocketManager.close).toHaveBeenCalledWith(
+      expect(webex.cc.services.rtdWebSocketManager.close).toHaveBeenNthCalledWith(
+        1,
+        false,
+        'Unregistering the SDK'
+      );
+      expect(webex.cc.services.rtdWebSocketManager.close).toHaveBeenNthCalledWith(
+        2,
         false,
         'Unregistering the RTD websocket'
       );
+      expect(webex.cc.services.rtdWebSocketManager.close).toHaveBeenCalledTimes(2);
       expect(webex.cc.agentConfig).toBeNull();
 
       expect(webex.internal.mercury.off).toHaveBeenCalledWith('online');
@@ -3210,6 +4449,7 @@ describe('webex.cc', () => {
         METRIC_EVENT_NAMES.WEBSOCKET_DEREGISTER_SUCCESS,
         METRIC_EVENT_NAMES.WEBSOCKET_DEREGISTER_FAIL,
       ]);
+      expect(mockTaskManager.clearAISummaryState).toHaveBeenCalled();
       expect(mockMetricsManager.trackEvent).toHaveBeenCalledWith(
         METRIC_EVENT_NAMES.WEBSOCKET_DEREGISTER_SUCCESS,
         {},
@@ -3229,22 +4469,23 @@ describe('webex.cc', () => {
       const incomingCalls = mockTaskManager.off.mock.calls.filter(
         ([evt]) => evt === TASK_EVENTS.TASK_INCOMING
       );
-      expect(incomingCalls).toHaveLength(1);
-      const [, incomingCallback] = incomingCalls[0];
+      expect(incomingCalls.length).toBeGreaterThanOrEqual(1);
+      const [, incomingCallback] = incomingCalls[incomingCalls.length - 1];
       expect(incomingCallback).toBe(webex.cc['handleIncomingTask']);
 
       const hydrateCalls = mockTaskManager.off.mock.calls.filter(
         ([evt]) => evt === TASK_EVENTS.TASK_HYDRATE
       );
-      expect(hydrateCalls).toHaveLength(1);
-      const [, hydrateCallback] = hydrateCalls[0];
+      expect(hydrateCalls.length).toBeGreaterThanOrEqual(1);
+      const [, hydrateCallback] = hydrateCalls[hydrateCalls.length - 1];
       expect(hydrateCallback).toBe(webex.cc['handleTaskHydrate']);
 
       const multiLoginHydrateCalls = mockTaskManager.off.mock.calls.filter(
         ([evt]) => evt === TASK_EVENTS.TASK_MULTI_LOGIN_HYDRATE
       );
-      expect(multiLoginHydrateCalls).toHaveLength(1);
-      const [, multiLoginHydrateCallback] = multiLoginHydrateCalls[0];
+      expect(multiLoginHydrateCalls.length).toBeGreaterThanOrEqual(1);
+      const [, multiLoginHydrateCallback] =
+        multiLoginHydrateCalls[multiLoginHydrateCalls.length - 1];
       expect(multiLoginHydrateCallback).toBe(webex.cc['handleTaskMultiLoginHydrate']);
 
       const messageCalls = mockWebSocketManager.off.mock.calls.filter(([evt]) => evt === 'message');
@@ -3318,7 +4559,17 @@ describe('webex.cc', () => {
       expect(webex.internal.mercury.off).not.toHaveBeenCalled();
       expect(mercuryDisconnectSpy).not.toHaveBeenCalled();
       expect(deviceUnregisterSpy).not.toHaveBeenCalled();
-      expect(mockRTDWebSocketManager.close).toHaveBeenCalledWith(false, 'Unregistering the SDK');
+      expect(mockRTDWebSocketManager.close).toHaveBeenNthCalledWith(
+        1,
+        false,
+        'Unregistering the SDK'
+      );
+      expect(mockRTDWebSocketManager.close).toHaveBeenNthCalledWith(
+        2,
+        false,
+        'Unregistering the RTD websocket'
+      );
+      expect(mockRTDWebSocketManager.close).toHaveBeenCalledTimes(2);
     });
 
     it('should skip internal mercury cleanup when loginVoiceOptions does not include BROWSER', async () => {
@@ -3336,7 +4587,17 @@ describe('webex.cc', () => {
       expect(deviceUnregisterSpy).not.toHaveBeenCalled();
 
       expect(mockWebSocketManager.close).toHaveBeenCalledWith(false, 'Unregistering the SDK');
-      expect(mockRTDWebSocketManager.close).toHaveBeenCalledWith(false, 'Unregistering the SDK');
+      expect(mockRTDWebSocketManager.close).toHaveBeenNthCalledWith(
+        1,
+        false,
+        'Unregistering the SDK'
+      );
+      expect(mockRTDWebSocketManager.close).toHaveBeenNthCalledWith(
+        2,
+        false,
+        'Unregistering the RTD websocket'
+      );
+      expect(mockRTDWebSocketManager.close).toHaveBeenCalledTimes(2);
       expect(webex.cc.agentConfig).toBeNull();
     });
 
@@ -3492,6 +4753,11 @@ describe('webex.cc', () => {
         module: CC_FILE,
         method: 'deregister',
       });
+      expect(mockTaskManager.clearAISummaryState).toHaveBeenCalled();
+      expect(webex.cc.services.rtdWebSocketManager.off).toHaveBeenCalledWith(
+        'message',
+        webex.cc['handleRTDWebsocketMessage']
+      );
 
       expect(mockMetricsManager.trackEvent).toHaveBeenCalledWith(
         METRIC_EVENT_NAMES.WEBSOCKET_DEREGISTER_FAIL,
@@ -4004,16 +5270,15 @@ describe('webex.cc', () => {
       mockError.details = {
         trackingId: 'test-tracking-id',
         orgId: 'mockOrgId',
-        error: 'Service error',
+        type: 'OutdialAniEntriesFailed',
+        data: {
+          reason: 'Detailed service error',
+        },
       };
 
       // Mock the service call to throw an error
       webex.cc.services.config.getOutdialAniEntries.mockRejectedValue(mockError);
 
-      // Mock getErrorDetails to return a detailed error
-      const detailedError = new Error('Detailed service error');
-      getErrorDetailsSpy.mockReturnValue({error: detailedError});
-
       await expect(webex.cc.getOutdialAniEntries(mockParams)).rejects.toThrow(
         'Detailed service error'
       );
@@ -4038,9 +5303,20 @@ describe('webex.cc', () => {
           trackingId: 'test-tracking-id',
         }
       );
+      expect(LoggerProxy.error).toHaveBeenCalledWith(
+        'getOutdialAniEntries failed with reason: Detailed service error',
+        {
+          module: CC_FILE,
+          method: 'getOutdialAniEntries',
+          trackingId: 'test-tracking-id',
+        }
+      );
 
       // Verify getErrorDetails was called
       expect(getErrorDetailsSpy).toHaveBeenCalledWith(mockError, 'getOutdialAniEntries', CC_FILE);
+      expect(mockWebexRequest.uploadLogs).toHaveBeenCalledWith({
+        correlationId: 'test-tracking-id',
+      });
     });
 
     it('should throw error when orgId is not found', async () => {
@@ -4123,8 +5399,7 @@ describe('webex.cc', () => {
     });
 
     it('should handle error during acceptPreviewContact', async () => {
-      getErrorDetailsSpy.mockRestore();
-      getErrorDetailsSpy = jest.spyOn(Utils, 'getErrorDetails');
+      getErrorDetailsSpy.mockClear();
 
       const error = {
         details: {
@@ -4150,6 +5425,9 @@ describe('webex.cc', () => {
         {module: CC_FILE, method: 'acceptPreviewContact', trackingId: error.details.trackingId}
       );
       expect(getErrorDetailsSpy).toHaveBeenCalledWith(error, 'acceptPreviewContact', CC_FILE);
+      expect(mockWebexRequest.uploadLogs).toHaveBeenCalledWith({
+        correlationId: error.details.trackingId,
+      });
     });
   });
 
@@ -4187,8 +5465,7 @@ describe('webex.cc', () => {
     });
 
     it('should handle error during skipPreviewContact', async () => {
-      getErrorDetailsSpy.mockRestore();
-      getErrorDetailsSpy = jest.spyOn(Utils, 'getErrorDetails');
+      getErrorDetailsSpy.mockClear();
 
       const error = {
         details: {
@@ -4214,6 +5491,9 @@ describe('webex.cc', () => {
         {module: CC_FILE, method: 'skipPreviewContact', trackingId: error.details.trackingId}
       );
       expect(getErrorDetailsSpy).toHaveBeenCalledWith(error, 'skipPreviewContact', CC_FILE);
+      expect(mockWebexRequest.uploadLogs).toHaveBeenCalledWith({
+        correlationId: error.details.trackingId,
+      });
     });
   });
 
@@ -4251,8 +5531,7 @@ describe('webex.cc', () => {
     });
 
     it('should handle error during removePreviewContact', async () => {
-      getErrorDetailsSpy.mockRestore();
-      getErrorDetailsSpy = jest.spyOn(Utils, 'getErrorDetails');
+      getErrorDetailsSpy.mockClear();
 
       const error = {
         details: {
@@ -4278,6 +5557,9 @@ describe('webex.cc', () => {
         {module: CC_FILE, method: 'removePreviewContact', trackingId: error.details.trackingId}
       );
       expect(getErrorDetailsSpy).toHaveBeenCalledWith(error, 'removePreviewContact', CC_FILE);
+      expect(mockWebexRequest.uploadLogs).toHaveBeenCalledWith({
+        correlationId: error.details.trackingId,
+      });
     });
   });