@webex/contact-center 3.12.0-llmrefactor.13 → 3.12.0-llmrefactor.15

package/src/services/wxAppDiagnosticLogging.ts

@@ -31,16 +31,54 @@ export function callIdSuffix(callId: string | null | undefined): string | undefi
   return callId.length <= 8 ? callId : callId.slice(-8);
 }
 
-function logWxApp(message: string, method: string, data: WxAppLogData): void {
-  LoggerProxy.info(`${WXAPP_LOG_PREFIX} ${message}`, {
+function formatLogSuffix(data: WxAppLogData, keys?: string[]): string {
+  const entries = keys
+    ? keys.map((key) => [key, data[key]] as const)
+    : Object.entries(data).filter(([key]) => key !== 'feature' && key !== 'event');
+
+  const parts = entries
+    .filter(([, value]) => value !== undefined && value !== null && value !== '')
+    .map(([key, value]) => `${key}=${String(value)}`);
+
+  return parts.length > 0 ? ` ${parts.join(' ')}` : '';
+}
+
+function logWxApp(
+  message: string,
+  method: string,
+  data: WxAppLogData,
+  suffixKeys?: string[]
+): void {
+  const suffix = formatLogSuffix(data, suffixKeys);
+  LoggerProxy.log(`${WXAPP_LOG_PREFIX} ${message}${suffix}`, {
+    module: 'wxAppDiagnosticLogging',
+    method,
+    data: {feature: WXAPP_LOG_FEATURE, ...data},
+  });
+}
+
+function logWxAppWarn(
+  message: string,
+  method: string,
+  data: WxAppLogData,
+  suffixKeys?: string[]
+): void {
+  const suffix = formatLogSuffix(data, suffixKeys);
+  LoggerProxy.warn(`${WXAPP_LOG_PREFIX} ${message}${suffix}`, {
     module: 'wxAppDiagnosticLogging',
     method,
     data: {feature: WXAPP_LOG_FEATURE, ...data},
   });
 }
 
-function logWxAppError(message: string, method: string, data: WxAppLogData): void {
-  LoggerProxy.error(`${WXAPP_LOG_PREFIX} ${message}`, {
+function logWxAppError(
+  message: string,
+  method: string,
+  data: WxAppLogData,
+  suffixKeys?: string[]
+): void {
+  const suffix = formatLogSuffix(data, suffixKeys);
+  LoggerProxy.error(`${WXAPP_LOG_PREFIX} ${message}${suffix}`, {
     module: 'wxAppDiagnosticLogging',
     method,
     data: {feature: WXAPP_LOG_FEATURE, ...data},
@@ -56,7 +94,7 @@ export function logWxAppSessionReadiness(params: {
   telephonyTaskType: 'Voice' | 'WebRTC' | 'unknown';
   skipReason?: WxAppSessionSkipReason;
 }): void {
-  logWxApp('session readiness', 'logWxAppSessionReadiness', {
+  const data: WxAppLogData = {
     event: 'session_readiness',
     enableWxBetterTogether: params.enableWxBetterTogether,
     loginOption: params.loginOption,
@@ -65,7 +103,16 @@ export function logWxAppSessionReadiness(params: {
     mercurySubscribed: params.mercurySubscribed,
     telephonyTaskType: params.telephonyTaskType,
     skipReason: params.skipReason,
-  });
+  };
+
+  logWxApp('session readiness', 'logWxAppSessionReadiness', data, [
+    'usersubPublished',
+    'mercurySubscribed',
+    'loginOption',
+    'enableWxBetterTogether',
+    'telephonyTaskType',
+    'skipReason',
+  ]);
 }
 
 export function deriveWxAppAcceptReason(params: {
@@ -111,8 +158,10 @@ export function logWxAppOfferDecision(params: {
   acceptReason: WxAppAcceptReason;
   wxAppParticipantDeviceType?: string;
   hasDeviceCallId: boolean;
+  hasDeviceId?: boolean;
+  usersubPublished?: boolean;
 }): void {
-  logWxApp('offer decision', 'logWxAppOfferDecision', {
+  const data: WxAppLogData = {
     event: 'offer_decision',
     interactionId: params.interactionId,
     acceptVisible: params.acceptVisible,
@@ -120,7 +169,51 @@ export function logWxAppOfferDecision(params: {
     acceptReason: params.acceptReason,
     wxAppParticipantDeviceType: params.wxAppParticipantDeviceType,
     hasDeviceCallId: params.hasDeviceCallId,
-  });
+    hasDeviceId: params.hasDeviceId,
+    usersubPublished: params.usersubPublished,
+  };
+
+  logWxApp('offer decision', 'logWxAppOfferDecision', data, [
+    'acceptReason',
+    'hasDeviceCallId',
+    'hasDeviceId',
+    'usersubPublished',
+    'interactionId',
+    'acceptVisible',
+    'acceptEnabled',
+  ]);
+}
+
+export function logWxAppOfferParticipantMismatch(params: {
+  interactionId: string;
+  usersubPublished: boolean;
+  hasDeviceCallId: boolean;
+  hasDeviceId: boolean;
+  participantDeviceType?: string;
+  acceptVisible: boolean;
+  acceptEnabled: boolean;
+  acceptReason: WxAppAcceptReason;
+}): void {
+  const data: WxAppLogData = {
+    event: 'participant_fields_mismatch',
+    interactionId: params.interactionId,
+    usersubPublished: params.usersubPublished,
+    hasDeviceCallId: params.hasDeviceCallId,
+    hasDeviceId: params.hasDeviceId,
+    participantDeviceType: params.participantDeviceType ?? 'missing',
+    acceptVisible: params.acceptVisible,
+    acceptEnabled: params.acceptEnabled,
+    acceptReason: params.acceptReason,
+  };
+
+  logWxAppWarn('participant fields mismatch', 'logWxAppOfferParticipantMismatch', data, [
+    'usersubPublished',
+    'hasDeviceCallId',
+    'hasDeviceId',
+    'acceptReason',
+    'interactionId',
+    'participantDeviceType',
+  ]);
 }
 
 export function logWxAppTelephonyAction(params: {
@@ -142,18 +235,32 @@ export function logWxAppTelephonyAction(params: {
   };
 
   if (params.phase === 'failed') {
-    logWxAppError(`telephony ${params.action} ${params.phase}`, 'logWxAppTelephonyAction', payload);
+    logWxAppError(
+      `telephony ${params.action} ${params.phase}`,
+      'logWxAppTelephonyAction',
+      payload,
+      ['interactionId', 'trackingId', 'httpStatus', 'failureReason']
+    );
   } else {
-    logWxApp(`telephony ${params.action} ${params.phase}`, 'logWxAppTelephonyAction', payload);
+    logWxApp(`telephony ${params.action} ${params.phase}`, 'logWxAppTelephonyAction', payload, [
+      'interactionId',
+      'action',
+      'phase',
+    ]);
   }
 }
 
 export function logWxAppValidationFailure(reason: string, interactionId?: string): void {
-  logWxAppError('validation failed', 'logWxAppValidationFailure', {
-    event: 'validation_failed',
-    reason,
-    interactionId,
-  });
+  logWxAppError(
+    'validation failed',
+    'logWxAppValidationFailure',
+    {
+      event: 'validation_failed',
+      reason,
+      interactionId,
+    },
+    ['reason', 'interactionId']
+  );
 }
 
 export function logWxAppMercuryMuteSync(params: {
@@ -163,12 +270,17 @@ export function logWxAppMercuryMuteSync(params: {
   interactionId?: string;
   dropReason?: string;
 }): void {
-  logWxApp(`mercury mute sync ${params.phase}`, 'logWxAppMercuryMuteSync', {
-    event: 'mercury_mute_sync',
-    phase: params.phase,
-    muted: params.muted,
-    callIdSuffix: params.callIdSuffix,
-    interactionId: params.interactionId,
-    dropReason: params.dropReason,
-  });
+  logWxApp(
+    `mercury mute sync ${params.phase}`,
+    'logWxAppMercuryMuteSync',
+    {
+      event: 'mercury_mute_sync',
+      phase: params.phase,
+      muted: params.muted,
+      callIdSuffix: params.callIdSuffix,
+      interactionId: params.interactionId,
+      dropReason: params.dropReason,
+    },
+    ['phase', 'muted', 'callIdSuffix', 'interactionId', 'dropReason']
+  );
 }

package/src/types.ts

@@ -618,6 +618,8 @@ export type ConfigFlags = {
   isRecordingEnabled?: boolean;
   /** Whether wxApp thick-client answer controls/APIs are enabled (WXCC-6026) */
   enableWxBetterTogether?: boolean;
+  /** Read-only observability: live usersub answer-calls-on-wxcc state for wxApp offer diagnostics. */
+  getWxAppUsersubPublished?: () => boolean;
 };
 
 /**

package/test/unit/spec/cc.ts

@@ -171,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(),
@@ -334,6 +336,7 @@ describe('webex.cc', () => {
         data: {
           auxCodeId: 'auxCodeId',
           agentId: 'agentId',
+          agentSessionId: 'session-after-refresh',
           deviceType: LoginOption.EXTENSION,
           dn: '12345',
         },
@@ -406,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,
@@ -653,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: {
@@ -1097,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 () => {
@@ -1227,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);
@@ -1639,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);
@@ -2213,6 +2363,36 @@ describe('webex.cc', () => {
       });
     });
 
+    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'],
@@ -2678,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 () => {
@@ -4140,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 () => {

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

@@ -160,11 +160,53 @@ describe('WebexCrossClientService', () => {
 
     expect(trackEvent).toHaveBeenCalledWith(
       METRIC_EVENT_NAMES.WXAPP_USERSUB_PUBLISH_FAILED,
-      expect.objectContaining({enableWxBetterTogether: true}),
+      expect.objectContaining({enableWxBetterTogether: true, usersubPublished: false}),
       ['operational', 'behavioral']
     );
   });
 
+  it('reports retained usersub state when disable publish fails after successful enable', async () => {
+    await service.setManageWebexCallingInWxcc(true, {trackPublishMetrics: true});
+    trackEvent.mockClear();
+
+    webex.request = jest.fn().mockRejectedValue(new Error('disable failed'));
+
+    await expect(
+      service.setManageWebexCallingInWxcc(false, {trackPublishMetrics: true})
+    ).rejects.toThrow('disable failed');
+
+    expect(trackEvent).toHaveBeenCalledWith(
+      METRIC_EVENT_NAMES.WXAPP_USERSUB_PUBLISH_FAILED,
+      expect.objectContaining({
+        enableWxBetterTogether: false,
+        usersubPublished: true,
+      }),
+      ['operational', 'behavioral']
+    );
+    expect(service.isAnswerCallsStateActive()).toBe(true);
+  });
+
+  it('reports retained usersub state when re-enable publish fails after successful enable', async () => {
+    await service.setManageWebexCallingInWxcc(true);
+    trackEvent.mockClear();
+
+    webex.request = jest.fn().mockRejectedValue(new Error('refresh failed'));
+
+    await expect(
+      service.setManageWebexCallingInWxcc(true, {trackPublishMetrics: true})
+    ).rejects.toThrow('refresh failed');
+
+    expect(trackEvent).toHaveBeenCalledWith(
+      METRIC_EVENT_NAMES.WXAPP_USERSUB_PUBLISH_FAILED,
+      expect.objectContaining({
+        enableWxBetterTogether: true,
+        usersubPublished: true,
+      }),
+      ['operational', 'behavioral']
+    );
+    expect(service.isAnswerCallsStateActive()).toBe(true);
+  });
+
   it('tracks usersub publish success when trackPublishMetrics is enabled', async () => {
     await service.setManageWebexCallingInWxcc(true, {trackPublishMetrics: true});
 
@@ -174,7 +216,7 @@ describe('WebexCrossClientService', () => {
     ]);
     expect(trackEvent).toHaveBeenCalledWith(
       METRIC_EVENT_NAMES.WXAPP_USERSUB_PUBLISH_SUCCESS,
-      {enableWxBetterTogether: true},
+      {enableWxBetterTogether: true, usersubPublished: true},
       ['operational', 'behavioral']
     );
   });
@@ -243,7 +285,7 @@ describe('WebexCrossClientService', () => {
     expect(cancelTimedEvent).not.toHaveBeenCalled();
     expect(trackEvent).toHaveBeenCalledWith(
       METRIC_EVENT_NAMES.WXAPP_USERSUB_PUBLISH_SUCCESS,
-      {enableWxBetterTogether: false},
+      {enableWxBetterTogether: false, usersubPublished: false},
       ['operational', 'behavioral']
     );
   });

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

@@ -42,7 +42,7 @@ describe('WxAppTelephonyMercurySync', () => {
     expect(sync.isSubscribed()).toBe(true);
     expect(trackEvent).toHaveBeenCalledWith(
       METRIC_EVENT_NAMES.WXAPP_MERCURY_SUBSCRIBE_SUCCESS,
-      {},
+      {mercurySubscribed: true},
       ['operational', 'behavioral']
     );
   });