@webex/contact-center 3.12.0-llmrefactor.12 → 3.12.0-llmrefactor.14

package/test/unit/spec/cc.ts

@@ -130,6 +130,7 @@ describe('webex.cc', () => {
       config: {
         getAgentConfig: jest.fn(),
         getOutdialAniEntries: jest.fn(),
+        getWellbeingBreakIdleCode: jest.fn(),
       },
       webSocketManager: mockWebSocketManager,
       rtdWebSocketManager: {
@@ -170,12 +171,14 @@ describe('webex.cc', () => {
       setAgentId: jest.fn(),
       setWebRtcEnabled: jest.fn(),
       setAnswerCallOnWebexService: jest.fn(),
+      handleRealtimeWebsocketEvent: jest.fn(),
       registerIncomingCallEvent: jest.fn(),
       registerTaskListeners: jest.fn(),
       getTask: jest.fn(),
       getActiveTasks: jest.fn(),
       applyEnableWxBetterTogether: jest.fn(),
       syncWxAppMuteFromCallDetailsForAllTasks: jest.fn(),
+      refreshWxAppOfferObservabilityForAllTasks: jest.fn(),
       on: jest.fn(),
       off: jest.fn(),
       emit: jest.fn(),
@@ -321,6 +324,7 @@ describe('webex.cc', () => {
       isTimeoutDesktopInactivityEnabled: false,
       webRtcEnabled: true,
       lostConnectionRecoveryTimeout: 0,
+      isWellnessBreakEnabled: false,
     };
 
     it('should register successfully and return agent profile', async () => {
@@ -332,6 +336,7 @@ describe('webex.cc', () => {
         data: {
           auxCodeId: 'auxCodeId',
           agentId: 'agentId',
+          agentSessionId: 'session-after-refresh',
           deviceType: LoginOption.EXTENSION,
           dn: '12345',
         },
@@ -404,22 +409,25 @@ describe('webex.cc', () => {
         module: CC_FILE,
         method: 'connectWebsocket',
       });
-      expect(mockTaskManager.setConfigFlags).toHaveBeenCalledWith({
-        isEndTaskEnabled: mockAgentProfile.isEndTaskEnabled,
-        isEndConsultEnabled: mockAgentProfile.isEndConsultEnabled,
-        webRtcEnabled: mockAgentProfile.webRtcEnabled,
-        autoWrapup: mockAgentProfile.wrapUpData.wrapUpProps.autoWrapup ?? false,
-        aiFeature: mockAgentProfile.aiFeature,
-        consultTransfer: {
-          allowConsultToQueue: mockAgentProfile.allowConsultToQueue,
-          accessQueue: mockAgentProfile.accessQueue,
-          accessEntryPoint: mockAgentProfile.accessEntryPoint,
-          accessBuddyTeam: mockAgentProfile.accessBuddyTeam,
-        },
-        enableWxBetterTogether: false,
-      });
+      expect(mockTaskManager.setConfigFlags).toHaveBeenCalledWith(
+        expect.objectContaining({
+          isEndTaskEnabled: mockAgentProfile.isEndTaskEnabled,
+          isEndConsultEnabled: mockAgentProfile.isEndConsultEnabled,
+          webRtcEnabled: mockAgentProfile.webRtcEnabled,
+          autoWrapup: mockAgentProfile.wrapUpData.wrapUpProps.autoWrapup ?? false,
+          aiFeature: mockAgentProfile.aiFeature,
+          consultTransfer: {
+            allowConsultToQueue: mockAgentProfile.allowConsultToQueue,
+            accessQueue: mockAgentProfile.accessQueue,
+            accessEntryPoint: mockAgentProfile.accessEntryPoint,
+            accessBuddyTeam: mockAgentProfile.accessBuddyTeam,
+          },
+          enableWxBetterTogether: false,
+          getWxAppUsersubPublished: expect.any(Function),
+        })
+      );
       expect(reloadSpy).toHaveBeenCalled();
-      expect(result).toEqual(mockAgentProfile);
+      expect(result).toEqual({...mockAgentProfile, agentSessionId: 'session-after-refresh'});
       expect(mockMetricsManager.timeEvent).toHaveBeenCalledWith([
         METRIC_EVENT_NAMES.WEBSOCKET_REGISTER_SUCCESS,
         METRIC_EVENT_NAMES.WEBSOCKET_REGISTER_FAILED,
@@ -496,6 +504,25 @@ describe('webex.cc', () => {
       );
     });
 
+    it('clears wellness session context when registration fails after relogin', async () => {
+      const mockError = new Error('Error after silent relogin');
+      webex.cc.$config = {...webex.cc.$config, allowAutomatedRelogin: true};
+      jest.spyOn(webex.cc.services.config, 'getAgentConfig').mockResolvedValue({
+        ...mockAgentProfile,
+        webRtcEnabled: false,
+        aiFeature: undefined,
+      } as Profile);
+      mockWebSocketManager.initWebSocket.mockResolvedValue({agentId: 'agent123'});
+      jest.spyOn(webex.cc as any, 'silentRelogin').mockImplementation(async () => {
+        webex.cc['updateWellnessSession']('partial-session');
+        throw mockError;
+      });
+
+      await expect(webex.cc.register()).rejects.toThrow(mockError);
+
+      expect(webex.cc['currentAgentSessionId']).toBeUndefined();
+    });
+
     it('should log error if mercury connect fails but cc.register() should not fail', async () => {
       const mockError = new Error('Error while performing mercury connect');
       jest.spyOn(webex.internal.mercury, 'connect').mockRejectedValue(mockError);
@@ -632,8 +659,47 @@ describe('webex.cc', () => {
       expect(result).toEqual(mockAgentProfile);
     });
 
-    it('should not connect RTD websocket when realtime transcripts feature is disabled', async () => {
-      mockAgentProfile.aiFeature = {realtimeTranscripts: {enable: false}} as any;
+    it('should connect RTD websocket when only wellness breaks are enabled', async () => {
+      mockAgentProfile.aiFeature = {
+        realtimeTranscripts: {enable: false},
+        suggestedResponses: {enable: false},
+      } as any;
+      mockAgentProfile.isWellnessBreakEnabled = true;
+      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',
+        },
+      });
+      jest.spyOn(webex.cc.services.config, 'getAgentConfig').mockResolvedValue(mockAgentProfile);
+      mockWebSocketManager.initWebSocket.mockResolvedValue({agentId: 'agent123'});
+
+      await webex.cc.register();
+
+      expect(webex.cc.services.rtdWebSocketManager.initWebSocket).toHaveBeenCalledWith({
+        body: {
+          force: true,
+          isKeepAliveEnabled: false,
+          clientType: 'WebexCCSDK',
+          allowMultiLogin: false,
+        },
+        resource: 'v1/realtime/subscribe',
+      });
+      expect(webex.cc.services.rtdWebSocketManager.on).toHaveBeenCalledWith(
+        'message',
+        expect.any(Function)
+      );
+    });
+
+    it('should not connect RTD websocket when transcripts, suggestions, and wellness are disabled', async () => {
+      mockAgentProfile.aiFeature = {
+        realtimeTranscripts: {enable: false},
+        suggestedResponses: {enable: false},
+      } as any;
+      mockAgentProfile.isWellnessBreakEnabled = false;
       jest.spyOn(webex.internal.mercury, 'connect').mockResolvedValue(true);
       jest.spyOn(webex.cc.services.agent, 'reload').mockResolvedValue({
         data: {
@@ -1076,6 +1142,7 @@ describe('webex.cc', () => {
 
       expect(publishSpy).toHaveBeenCalledWith(true, {userId: 'user-123', trackPublishMetrics: true});
       expect(subscribeSpy).toHaveBeenCalledWith('agentId', expect.any(Function));
+      expect(mockTaskManager.refreshWxAppOfferObservabilityForAllTasks).toHaveBeenCalled();
     });
 
     it('should rollback wxApp config when post-station-login init fails', async () => {
@@ -1206,7 +1273,57 @@ describe('webex.cc', () => {
 
       expect(metricSpy).toHaveBeenCalledWith(
         METRIC_EVENT_NAMES.WXAPP_SESSION_INIT_FAILED,
-        expect.objectContaining({skipReason: 'publish_failed'}),
+        expect.objectContaining({skipReason: 'publish_failed', usersubPublished: false}),
+        ['operational', 'behavioral']
+      );
+      expect(webex.cc.isWxBetterTogetherEnabled()).toBe(false);
+    });
+
+    it('should report retained usersub state when publish fails during re-init', async () => {
+      webex.cc.$config = {...webex.cc.$config, enableWxBetterTogether: true};
+      webex.internal.device = {userId: 'user-123', url: 'https://wdm.example.com/devices/dev-1'};
+      webex.cc.agentConfig = {
+        agentId: 'agentId',
+        webRtcEnabled: false,
+        loginVoiceOptions: ['EXTENSION'],
+      };
+      webex.cc.webCallingService.loginOption = LoginOption.EXTENSION;
+      mockTaskManager.applyEnableWxBetterTogether(true);
+
+      jest.spyOn(webex.cc as any, 'ensureWxAppMercuryConnected').mockResolvedValue(undefined);
+      jest
+        .spyOn(webex.cc['wxAppTelephonyMercurySync'], 'subscribe')
+        .mockImplementation(() => {});
+      jest.spyOn(webex.cc['wxAppTelephonyMercurySync'], 'isSubscribed').mockReturnValue(true);
+      jest
+        .spyOn(webex.cc['webexCrossClientService'], 'isAnswerCallsStateActive')
+        .mockReturnValue(true);
+      jest
+        .spyOn(webex.cc['webexCrossClientService'], 'setManageWebexCallingInWxcc')
+        .mockRejectedValue(new Error('publish failed'));
+      jest
+        .spyOn(webex.cc as any, 'releaseWxAppMercuryResources')
+        .mockResolvedValue(undefined);
+      const metricSpy = jest.spyOn(mockMetricsManager, 'trackEvent');
+
+      jest.spyOn(webex.cc.services.agent, 'stationLogin').mockResolvedValue({
+        data: {
+          agentId: 'agentId',
+          teamId: 'teamId',
+          channelsMap: {chat: [], email: [], social: [], telephony: []},
+        },
+        trackingId: 'track-1',
+      } as StationLoginSuccess);
+
+      await webex.cc.stationLogin({
+        teamId: 'teamId',
+        loginOption: LoginOption.EXTENSION,
+        dialNumber: '1001',
+      });
+
+      expect(metricSpy).toHaveBeenCalledWith(
+        METRIC_EVENT_NAMES.WXAPP_SESSION_INIT_FAILED,
+        expect.objectContaining({skipReason: 'publish_failed', usersubPublished: true}),
         ['operational', 'behavioral']
       );
       expect(webex.cc.isWxBetterTogetherEnabled()).toBe(false);
@@ -1618,7 +1735,61 @@ describe('webex.cc', () => {
       );
       expect(metricSpy).toHaveBeenCalledWith(
         METRIC_EVENT_NAMES.WXAPP_USERSUB_PUBLISH_FAILED,
-        expect.objectContaining({skipReason: 'user_id_unavailable'}),
+        expect.objectContaining({skipReason: 'user_id_unavailable', usersubPublished: false}),
+        ['operational', 'behavioral']
+      );
+      expect(webex.cc.isWxBetterTogetherEnabled()).toBe(true);
+    });
+
+    it('should report retained usersub state when userId is missing during re-init', async () => {
+      webex.cc.$config = {...webex.cc.$config, enableWxBetterTogether: true};
+      webex.internal.device = {
+        url: 'https://wdm.example.com/devices/dev-1',
+        registered: true,
+        register: jest.fn().mockResolvedValue(undefined),
+      };
+      webex.internal.mercury = {
+        connected: true,
+        connect: jest.fn().mockResolvedValue(undefined),
+        on: jest.fn(),
+        off: jest.fn(),
+      };
+      webex.cc.agentConfig = {
+        agentId: 'agentId',
+        webRtcEnabled: false,
+        loginVoiceOptions: ['EXTENSION'],
+      };
+      webex.cc.webCallingService.loginOption = LoginOption.EXTENSION;
+      mockTaskManager.applyEnableWxBetterTogether(true);
+
+      jest
+        .spyOn(webex.cc['webexCrossClientService'], 'isAnswerCallsStateActive')
+        .mockReturnValue(true);
+      const publishSpy = jest
+        .spyOn(webex.cc['webexCrossClientService'], 'setManageWebexCallingInWxcc')
+        .mockResolvedValue(undefined);
+      jest.spyOn(webex.cc['wxAppTelephonyMercurySync'], 'isSubscribed').mockReturnValue(true);
+      const metricSpy = jest.spyOn(mockMetricsManager, 'trackEvent');
+
+      jest.spyOn(webex.cc.services.agent, 'stationLogin').mockResolvedValue({
+        data: {
+          agentId: 'agentId',
+          teamId: 'teamId',
+          channelsMap: {chat: [], email: [], social: [], telephony: []},
+        },
+        trackingId: 'track-1',
+      } as StationLoginSuccess);
+
+      await webex.cc.stationLogin({
+        teamId: 'teamId',
+        loginOption: LoginOption.EXTENSION,
+        dialNumber: '1001',
+      });
+
+      expect(publishSpy).not.toHaveBeenCalledWith(true, expect.anything());
+      expect(metricSpy).toHaveBeenCalledWith(
+        METRIC_EVENT_NAMES.WXAPP_USERSUB_PUBLISH_FAILED,
+        expect.objectContaining({skipReason: 'user_id_unavailable', usersubPublished: true}),
         ['operational', 'behavioral']
       );
       expect(webex.cc.isWxBetterTogetherEnabled()).toBe(true);
@@ -2070,6 +2241,257 @@ describe('webex.cc', () => {
     });
   });
 
+  describe('Agent Wellness Break SDK contracts', () => {
+    const wellbeingCode = {
+      id: 'wellbeing-code',
+      name: 'WellbeingBreak',
+      isSystem: true,
+      isDefault: false,
+    };
+
+    beforeEach(() => {
+      webex.cc.agentConfig = {
+        agentId: 'agent-1',
+        isWellnessBreakEnabled: true,
+      } as Profile;
+      webex.cc['updateWellnessSession']('session-1');
+    });
+
+    it('fetches the system idle code once per registration', async () => {
+      const lookup = jest
+        .spyOn(webex.cc.services.config, 'getWellbeingBreakIdleCode')
+        .mockResolvedValue(wellbeingCode);
+
+      await expect(webex.cc.getWellbeingBreakIdleCode()).resolves.toEqual(wellbeingCode);
+      await expect(webex.cc.getWellbeingBreakIdleCode()).resolves.toEqual(wellbeingCode);
+
+      expect(lookup).toHaveBeenCalledTimes(1);
+      expect(lookup).toHaveBeenCalledWith('mockOrgId');
+    });
+
+    it('does not cache an idle-code lookup that completes after a new registration starts', async () => {
+      let resolveLookup: (idleCode: typeof wellbeingCode) => void = () => undefined;
+      jest
+        .spyOn(webex.cc.services.config, 'getWellbeingBreakIdleCode')
+        .mockImplementation(
+          () =>
+            new Promise((resolve) => {
+              resolveLookup = resolve;
+            })
+        );
+
+      const lookupPromise = webex.cc.getWellbeingBreakIdleCode();
+      const staleLookup = expect(lookupPromise).rejects.toThrow(
+        'WELLNESS_BREAK_REGISTRATION_CHANGED'
+      );
+      jest
+        .spyOn(webex.cc, 'connectWebsocket')
+        .mockRejectedValue(new Error('replacement registration failed'));
+
+      await expect(webex.cc.register()).rejects.toThrow('replacement registration failed');
+      resolveLookup(wellbeingCode);
+
+      await staleLookup;
+      expect(webex.cc['wellbeingBreakIdleCode']).toBeUndefined();
+    });
+
+    it('rejects the system idle-code lookup when wellness is disabled', async () => {
+      webex.cc.agentConfig.isWellnessBreakEnabled = false;
+
+      await expect(webex.cc.getWellbeingBreakIdleCode()).rejects.toThrow(
+        'WELLNESS_BREAK_NOT_ENABLED'
+      );
+      expect(webex.cc.services.config.getWellbeingBreakIdleCode).not.toHaveBeenCalled();
+    });
+
+    it('invalidates the wellness session only for a current-session multi-login close', () => {
+      webex.cc['handleWebsocketMessage'](
+        JSON.stringify({
+          type: CC_EVENTS.AGENT_MULTI_LOGIN,
+          data: {
+            type: 'AgentMultiLoginCloseSession',
+            agentSessionId: 'another-session',
+          },
+        })
+      );
+      expect(webex.cc['currentAgentSessionId']).toBe('session-1');
+
+      webex.cc['handleWebsocketMessage'](
+        JSON.stringify({
+          type: CC_EVENTS.AGENT_MULTI_LOGIN,
+          data: {
+            type: 'AgentMultiLoginCloseSession',
+            agentSessionId: 'session-1',
+          },
+        })
+      );
+      expect(webex.cc['currentAgentSessionId']).toBeUndefined();
+    });
+
+    it('emits primary wellness notifications regardless of notification session metadata', () => {
+      const emitSpy = jest.spyOn(webex.cc, 'emit');
+      const payload = {
+        type: 'Wellness_Break_Handler',
+        orgId: 'mockOrgId',
+        trackingId: 'data-notification-tracking',
+        data: {
+          agentId: 'agent-1',
+          orgId: 'mockOrgId',
+          notifType: 'Wellness_Break_Handler',
+          notifDetails: {
+            actionEvent: 'SUGGEST_WELLNESS_BREAK',
+            actionText: 'How about a break?',
+          },
+          data: {
+            orgId: 'mockOrgId',
+            agentSessionId: 'notification-session',
+            interactionId: 'interaction-1',
+          },
+        },
+      };
+
+      webex.cc['handleWebsocketMessage'](JSON.stringify(payload));
+
+      expect(emitSpy).toHaveBeenCalledWith(CC_EVENTS.WELLNESS_BREAK, {
+        agentId: 'agent-1',
+        orgId: 'mockOrgId',
+        agentSessionId: 'notification-session',
+        actionEvent: 'SUGGEST_WELLNESS_BREAK',
+        actionText: 'How about a break?',
+        interactionId: 'interaction-1',
+        trackingId: 'data-notification-tracking',
+      });
+    });
+
+    it('routes data-socket wellness notifications without sending them to TaskManager', () => {
+      const emitSpy = jest.spyOn(webex.cc, 'emit');
+      const taskEventSpy = mockTaskManager.handleRealtimeWebsocketEvent;
+      const wellnessMessage = JSON.stringify({
+        type: 'Wellness_Break_Handler',
+        orgId: 'mockOrgId',
+        data: {
+          agentId: 'agent-1',
+          orgId: 'mockOrgId',
+          notifType: 'Wellness_Break_Handler',
+          notifDetails: {actionEvent: 'PROVIDE_WELLNESS_BREAK'},
+          data: {orgId: 'mockOrgId', agentSessionId: 'notification-session'},
+        },
+      });
+
+      webex.cc['handleRTDWebsocketMessage'](wellnessMessage);
+
+      expect(emitSpy).toHaveBeenCalledWith(CC_EVENTS.WELLNESS_BREAK, {
+        agentId: 'agent-1',
+        orgId: 'mockOrgId',
+        agentSessionId: 'notification-session',
+        actionEvent: 'PROVIDE_WELLNESS_BREAK',
+      });
+      expect(taskEventSpy).not.toHaveBeenCalled();
+
+      const transcriptMessage = JSON.stringify({type: CC_EVENTS.REAL_TIME_TRANSCRIPTION});
+      webex.cc['handleRTDWebsocketMessage'](transcriptMessage);
+      expect(taskEventSpy).toHaveBeenCalledWith(transcriptMessage);
+    });
+
+    it.each([
+      ['SUGGEST_WELLNESS_BREAK', 'interactionId'],
+      ['WELLNESS_BREAK_NOT_ALLOWED', 'InteractionId'],
+    ])('normalizes the %s action and either interaction-id spelling', (actionEvent, key) => {
+      const emitSpy = jest.spyOn(webex.cc, 'emit');
+      webex.cc['handleWebsocketMessage'](
+        JSON.stringify({
+          type: 'Wellness_Break_Handler',
+          orgId: 'mockOrgId',
+          data: {
+            agentId: 'agent-1',
+            orgId: 'mockOrgId',
+            notifType: 'Wellness_Break_Handler',
+            notifDetails: {actionEvent},
+            data: {
+              orgId: 'mockOrgId',
+              agentSessionId: 'session-1',
+              [key]: 'interaction-2',
+            },
+          },
+        })
+      );
+
+      expect(emitSpy).toHaveBeenCalledWith(
+        CC_EVENTS.WELLNESS_BREAK,
+        expect.objectContaining({actionEvent, interactionId: 'interaction-2'})
+      );
+    });
+
+    it('does not promote uncontracted notification text fields', () => {
+      const emitSpy = jest.spyOn(webex.cc, 'emit');
+      webex.cc['handleWebsocketMessage'](
+        JSON.stringify({
+          type: 'Wellness_Break_Handler',
+          orgId: 'mockOrgId',
+          trackingId: 'notification-tracking',
+          data: {
+            agentId: 'agent-1',
+            orgId: 'mockOrgId',
+            notifType: 'Wellness_Break_Handler',
+            notifDetails: {
+              actionEvent: 'SUGGEST_WELLNESS_BREAK',
+              actionText2: 'Uncontracted text',
+            },
+            data: {
+              orgId: 'mockOrgId',
+              agentSessionId: 'session-1',
+              InteractionId: 'interaction-qa',
+            },
+          },
+        })
+      );
+
+      expect(emitSpy).toHaveBeenCalledWith(CC_EVENTS.WELLNESS_BREAK, {
+        agentId: 'agent-1',
+        orgId: 'mockOrgId',
+        agentSessionId: 'session-1',
+        actionEvent: 'SUGGEST_WELLNESS_BREAK',
+        interactionId: 'interaction-qa',
+        trackingId: 'notification-tracking',
+      });
+    });
+
+    it('ignores wellness events when the effective flag is disabled or identity is missing', () => {
+      const emitSpy = jest.spyOn(webex.cc, 'emit');
+      const payload = {
+        type: 'Wellness_Break_Handler',
+        orgId: 'mockOrgId',
+        data: {
+          agentId: 'agent-1',
+          orgId: 'mockOrgId',
+          notifType: 'Wellness_Break_Handler',
+          notifDetails: {actionEvent: 'SUGGEST_WELLNESS_BREAK'},
+          data: {orgId: 'mockOrgId', agentSessionId: 'session-1'},
+        },
+      };
+
+      webex.cc.agentConfig.isWellnessBreakEnabled = false;
+      webex.cc['handleWebsocketMessage'](JSON.stringify(payload));
+      webex.cc.agentConfig.isWellnessBreakEnabled = true;
+      const {orgId: omittedOrgId, ...payloadWithoutEnvelopeOrg} = payload;
+      expect(omittedOrgId).toBe('mockOrgId');
+      webex.cc['handleWebsocketMessage'](JSON.stringify(payloadWithoutEnvelopeOrg));
+
+      expect(emitSpy).not.toHaveBeenCalledWith(CC_EVENTS.WELLNESS_BREAK, expect.anything());
+      expect(mockMetricsManager.trackEvent).toHaveBeenCalledWith(
+        METRIC_EVENT_NAMES.AI_ASSISTANT_WELLNESS_EVENT_INVALID,
+        {reason: 'wellness_disabled'},
+        ['operational']
+      );
+      expect(mockMetricsManager.trackEvent).toHaveBeenCalledWith(
+        METRIC_EVENT_NAMES.AI_ASSISTANT_WELLNESS_EVENT_INVALID,
+        {reason: 'missing_wellness_identity'},
+        ['operational']
+      );
+    });
+
+  });
+
   describe('getBuddyAgents', () => {
     it('should return buddy agents response when successful', async () => {
       const data: BuddyAgents = {state: 'Available', mediaType: 'telephony'};
@@ -2436,6 +2858,7 @@ describe('webex.cc', () => {
 
       expect(publishSpy).toHaveBeenCalledWith(true, {userId: 'user-123', trackPublishMetrics: true});
       expect(subscribeSpy).toHaveBeenCalledWith('agentId', expect.any(Function));
+      expect(mockTaskManager.refreshWxAppOfferObservabilityForAllTasks).toHaveBeenCalled();
     });
 
     it('should force-publish usersub false on silent relogin when enableWxBetterTogether is false at init', async () => {
@@ -2701,6 +3124,32 @@ describe('webex.cc', () => {
       deviceUnregisterSpy = jest.spyOn(webex.internal.device, 'unregister');
     });
 
+    it('invalidates wellness context before deregistration cleanup can fail', async () => {
+      const cleanupError = new Error('cleanup failed');
+      let rejectCleanup: (error: Error) => void = () => undefined;
+      const cleanup = new Promise((resolve, reject) => {
+        rejectCleanup = reject;
+      });
+      webex.cc.agentConfig = {
+        ...webex.cc.agentConfig,
+        isWellnessBreakEnabled: true,
+      };
+      webex.cc['updateWellnessSession']('session-1');
+      jest.spyOn(webex.cc as any, 'teardownWxAppLocalState').mockReturnValue(cleanup);
+
+      const deregistration = webex.cc.deregister();
+      const rejection = expect(deregistration).rejects.toThrow(cleanupError);
+
+      expect(webex.cc['currentAgentSessionId']).toBeUndefined();
+      await expect(webex.cc.apiAIAssistant.requestWellnessBreak()).rejects.toThrow(
+        'WELLNESS_BREAK_AGENT_SESSION_REQUIRED'
+      );
+
+      rejectCleanup(cleanupError);
+      await rejection;
+      expect(webex.cc['currentAgentSessionId']).toBeUndefined();
+    });
+
     it('should unregister successfully and clean up all resources when webrtc is enabled', async () => {
       webex.cc.services.rtdWebSocketManager = {
         isSocketClosed: false,
@@ -3872,6 +4321,7 @@ describe('webex.cc', () => {
       expect(webex.cc.isWxBetterTogetherEnabled()).toBe(true);
       expect(mockTaskManager.applyEnableWxBetterTogether).toHaveBeenCalledWith(true);
       expect(publishSpy).toHaveBeenCalledWith(true, {userId: 'user-123', trackPublishMetrics: true});
+      expect(mockTaskManager.refreshWxAppOfferObservabilityForAllTasks).toHaveBeenCalled();
     });
 
     it('should publish false and update config when disabled after wxApp was enabled', async () => {