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

package/test/unit/spec/services/task/voice/Voice.ts

@@ -1006,69 +1006,28 @@ describe('Voice Task', () => {
     });
   });
 
-  describe('wxApp offer decision logging', () => {
-    const wxAppParticipant = {
-      deviceType: 'wxApp',
-      deviceId: 'device-id-1',
-      deviceCallId: 'call-id-1',
-    };
-
-    const makeWxAppOfferTaskData = () =>
-      createBaseData({
-        agentId: 'agent-1',
-        interaction: {
-          participants: {
-            'agent-1': {id: 'agent-1', ...wxAppParticipant},
-          },
-        } as any,
-      });
-
-    it('logs evolving accept reasons through the normal wxApp accept flow', () => {
-      const logSpy = jest.spyOn(wxAppDiagnosticLogging, 'logWxAppOfferDecision');
-      const taskData = makeWxAppOfferTaskData();
-      const voice = new Voice(dummyContact, taskData, {enableWxBetterTogether: true});
-
-      voice.stateMachineService?.send({type: TaskEvent.TASK_INCOMING, taskData});
-
-      expect(logSpy).toHaveBeenCalledWith(
-        expect.objectContaining({acceptReason: 'wxApp_offer_ready'})
-      );
-
-      logSpy.mockClear();
-      voice['setWxAppAcceptInFlight'](true);
-
-      expect(logSpy).toHaveBeenCalledWith(
-        expect.objectContaining({acceptReason: 'wxApp_accept_in_flight'})
-      );
-
-      logSpy.mockClear();
-      voice['setWxAppAcceptInFlight'](false);
-      voice['setWxAppAnswerPending'](true);
-
-      expect(logSpy).toHaveBeenCalledWith(
-        expect.objectContaining({acceptReason: 'wxApp_answer_pending'})
-      );
-    });
-
-    it('logs browser_webrtc_offer when voice variant is WebRTC on a non-wxApp inbound offer', () => {
+  describe('wxApp offer observability integration', () => {
+    it('delegates OFFERED ui control updates to wxApp offer observability', () => {
       const logSpy = jest.spyOn(wxAppDiagnosticLogging, 'logWxAppOfferDecision');
       const taskData = createBaseData({
         agentId: 'agent-1',
         interaction: {
           participants: {
-            'agent-1': {id: 'agent-1', deviceType: 'phone', deviceId: 'device-id-1'},
+            'agent-1': {
+              id: 'agent-1',
+              deviceType: 'wxApp',
+              deviceId: 'device-id-1',
+              deviceCallId: 'call-id-1',
+            },
           },
         } as any,
       });
-      const voice = new Voice(dummyContact, taskData, {
-        enableWxBetterTogether: true,
-        voiceVariant: VOICE_VARIANT.WEBRTC,
-      });
+      const voice = new Voice(dummyContact, taskData, {enableWxBetterTogether: true});
 
       voice.stateMachineService?.send({type: TaskEvent.TASK_INCOMING, taskData});
 
       expect(logSpy).toHaveBeenCalledWith(
-        expect.objectContaining({acceptReason: 'browser_webrtc_offer'})
+        expect.objectContaining({acceptReason: 'wxApp_offer_ready'})
       );
     });
   });

package/test/unit/spec/services/task/voice/wxAppOfferObservability.ts

@@ -0,0 +1,361 @@
+import MetricsManager from '../../../../../../src/metrics/MetricsManager';
+import {METRIC_EVENT_NAMES} from '../../../../../../src/metrics/constants';
+import {TaskState} from '../../../../../../src/services/task/state-machine';
+import {TaskData, VOICE_VARIANT} from '../../../../../../src/services/task/types';
+import {
+  WxAppOfferObservability,
+  WxAppOfferObservabilityContext,
+  WXAPP_PARTICIPANT_MISMATCH_GRACE_MS,
+} from '../../../../../../src/services/task/voice/wxAppOfferObservability';
+import {WxAppVoiceDependencies} from '../../../../../../src/services/task/voice/wxAppVoiceMethods';
+import * as wxAppDiagnosticLogging from '../../../../../../src/services/wxAppDiagnosticLogging';
+import {createTaskData} from '../taskTestUtils';
+
+const wxAppParticipant = {
+  deviceType: 'wxApp',
+  deviceId: 'device-id-1',
+  deviceCallId: 'call-id-1',
+};
+
+function makeTaskDataWithoutWxAppFields(): TaskData {
+  return createTaskData({
+    agentId: 'agent-1',
+    interaction: {
+      participants: {
+        'agent-1': {id: 'agent-1'},
+      },
+    } as TaskData['interaction'],
+  });
+}
+
+function makeTaskDataWithWxAppFields(): TaskData {
+  return createTaskData({
+    agentId: 'agent-1',
+    interaction: {
+      participants: {
+        'agent-1': {id: 'agent-1', ...wxAppParticipant},
+      },
+    } as TaskData['interaction'],
+  });
+}
+
+function makeMockMetricsManager(): jest.Mocked<Pick<MetricsManager, 'trackEvent'>> {
+  return {trackEvent: jest.fn()};
+}
+
+function makeContext(
+  overrides: {
+    taskData?: TaskData;
+    taskState?: TaskState;
+    usersubPublished?: boolean;
+    wxAppAcceptInFlight?: boolean;
+    wxAppAnswerPending?: boolean;
+    voiceVariant?: typeof VOICE_VARIANT.PSTN;
+    acceptEnabled?: boolean;
+    isOutdial?: boolean;
+  } = {}
+): WxAppOfferObservabilityContext & {
+  setTaskData: (data: TaskData) => void;
+  setTaskState: (s: TaskState) => void;
+  setUsersubPublished: (value: boolean) => void;
+} {
+  let taskData = overrides.taskData ?? makeTaskDataWithoutWxAppFields();
+  let taskState = overrides.taskState ?? TaskState.OFFERED;
+  let usersubPublished = overrides.usersubPublished ?? true;
+  const metricsManager = makeMockMetricsManager() as unknown as MetricsManager;
+
+  const deps = (): WxAppVoiceDependencies => ({
+    enableWxBetterTogether: true,
+    agentId: 'agent-1',
+    metricsManager,
+    getTaskData: () => taskData,
+    getTaskState: () => taskState,
+    getWxAppMuted: () => false,
+    setWxAppMuted: jest.fn(),
+    getUsersubPublished: () => usersubPublished,
+  });
+
+  return {
+    getInteractionId: () => taskData.interactionId,
+    getTaskState: () => taskState,
+    getAcceptControl: () => ({
+      isVisible: true,
+      isEnabled: overrides.acceptEnabled ?? false,
+    }),
+    getVoiceVariant: () => overrides.voiceVariant ?? VOICE_VARIANT.PSTN,
+    isOutdial: () => overrides.isOutdial ?? false,
+    isWxAppInboundOffer: () => {
+      const p = taskData.interaction?.participants?.['agent-1'] as
+        | {deviceType?: string; deviceCallId?: string; deviceId?: string}
+        | undefined;
+      return (
+        p?.deviceType === 'wxApp' &&
+        typeof p.deviceCallId === 'string' &&
+        p.deviceCallId.trim() !== '' &&
+        typeof p.deviceId === 'string' &&
+        p.deviceId.trim() !== ''
+      );
+    },
+    isWxAppCallingOffer: () => {
+      const p = taskData.interaction?.participants?.['agent-1'] as
+        | {deviceType?: string; deviceCallId?: string; deviceId?: string}
+        | undefined;
+      return (
+        p?.deviceType === 'wxApp' &&
+        typeof p.deviceCallId === 'string' &&
+        p.deviceCallId.trim() !== '' &&
+        typeof p.deviceId === 'string' &&
+        p.deviceId.trim() !== ''
+      );
+    },
+    getWxAppAcceptInFlight: () => overrides.wxAppAcceptInFlight ?? false,
+    getWxAppAnswerPending: () => overrides.wxAppAnswerPending ?? false,
+    getEnableWxBetterTogether: () => true,
+    getUsersubPublished: () => usersubPublished,
+    getWxAppVoiceDependencies: deps,
+    getMetricsManager: () => metricsManager,
+    setTaskData: (data: TaskData) => {
+      taskData = data;
+    },
+    setTaskState: (state: TaskState) => {
+      taskState = state;
+    },
+    setUsersubPublished: (value: boolean) => {
+      usersubPublished = value;
+    },
+  };
+}
+
+describe('WxAppOfferObservability', () => {
+  beforeEach(() => {
+    jest.useFakeTimers();
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+  });
+
+  describe('offer decision logging', () => {
+    it('logs wxApp_offer_ready when participant fields are present', () => {
+      const logSpy = jest.spyOn(wxAppDiagnosticLogging, 'logWxAppOfferDecision');
+      const observability = new WxAppOfferObservability();
+      const ctx = makeContext({taskData: makeTaskDataWithWxAppFields(), acceptEnabled: true});
+
+      observability.handleUiControlsUpdate(ctx);
+
+      expect(logSpy).toHaveBeenCalledWith(
+        expect.objectContaining({acceptReason: 'wxApp_offer_ready'})
+      );
+    });
+
+    it('logs accept reason transitions only once per reason', () => {
+      const logSpy = jest.spyOn(wxAppDiagnosticLogging, 'logWxAppOfferDecision');
+      const observability = new WxAppOfferObservability();
+      const ctx = makeContext({
+        taskData: makeTaskDataWithWxAppFields(),
+        wxAppAcceptInFlight: true,
+      });
+
+      observability.handleUiControlsUpdate(ctx);
+      observability.handleUiControlsUpdate(ctx);
+
+      expect(logSpy).toHaveBeenCalledTimes(1);
+      expect(logSpy).toHaveBeenCalledWith(
+        expect.objectContaining({acceptReason: 'wxApp_accept_in_flight'})
+      );
+    });
+
+    it('logs browser_webrtc_offer for WebRTC variant without wxApp participant', () => {
+      const logSpy = jest.spyOn(wxAppDiagnosticLogging, 'logWxAppOfferDecision');
+      const observability = new WxAppOfferObservability();
+      const ctx = makeContext({
+        taskData: createTaskData({
+          agentId: 'agent-1',
+          interaction: {
+            participants: {
+              'agent-1': {id: 'agent-1', deviceType: 'phone', deviceId: 'device-id-1'},
+            },
+          } as TaskData['interaction'],
+        }),
+        voiceVariant: VOICE_VARIANT.WEBRTC,
+      });
+
+      observability.handleUiControlsUpdate(ctx);
+
+      expect(logSpy).toHaveBeenCalledWith(
+        expect.objectContaining({acceptReason: 'browser_webrtc_offer'})
+      );
+    });
+  });
+
+  describe('deferred participant mismatch', () => {
+    it('does not warn when wxApp fields arrive before grace period elapses', () => {
+      const warnSpy = jest.spyOn(wxAppDiagnosticLogging, 'logWxAppOfferParticipantMismatch');
+      const observability = new WxAppOfferObservability();
+      const ctx = makeContext();
+
+      observability.handleUiControlsUpdate(ctx);
+      expect(warnSpy).not.toHaveBeenCalled();
+
+      ctx.setTaskData(makeTaskDataWithWxAppFields());
+      observability.handleUiControlsUpdate(ctx);
+
+      jest.advanceTimersByTime(WXAPP_PARTICIPANT_MISMATCH_GRACE_MS);
+
+      expect(warnSpy).not.toHaveBeenCalled();
+      expect(ctx.getMetricsManager().trackEvent).not.toHaveBeenCalledWith(
+        METRIC_EVENT_NAMES.WXAPP_OFFER_PARTICIPANT_FIELDS_MISSING,
+        expect.anything(),
+        expect.anything()
+      );
+    });
+
+    it('warns and emits metric when fields remain missing after grace period', () => {
+      const warnSpy = jest.spyOn(wxAppDiagnosticLogging, 'logWxAppOfferParticipantMismatch');
+      const observability = new WxAppOfferObservability();
+      const ctx = makeContext();
+
+      observability.handleUiControlsUpdate(ctx);
+      expect(warnSpy).not.toHaveBeenCalled();
+
+      jest.advanceTimersByTime(WXAPP_PARTICIPANT_MISMATCH_GRACE_MS);
+
+      expect(warnSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          interactionId: 'interaction-1',
+          usersubPublished: true,
+          hasDeviceCallId: false,
+          hasDeviceId: false,
+          acceptReason: 'extension_non_wxApp_offer',
+        })
+      );
+      expect(ctx.getMetricsManager().trackEvent).toHaveBeenCalledWith(
+        METRIC_EVENT_NAMES.WXAPP_OFFER_PARTICIPANT_FIELDS_MISSING,
+        expect.objectContaining({
+          taskId: 'interaction-1',
+          usersubPublished: true,
+          hasDeviceCallId: false,
+          hasDeviceId: false,
+          acceptReason: 'extension_non_wxApp_offer',
+        }),
+        ['operational', 'behavioral']
+      );
+    });
+
+    it('cancels pending mismatch when task leaves OFFERED before grace period', () => {
+      const warnSpy = jest.spyOn(wxAppDiagnosticLogging, 'logWxAppOfferParticipantMismatch');
+      const observability = new WxAppOfferObservability();
+      const ctx = makeContext();
+
+      observability.handleUiControlsUpdate(ctx);
+      ctx.setTaskState(TaskState.TERMINATED);
+      observability.handleUiControlsUpdate(ctx);
+
+      jest.advanceTimersByTime(WXAPP_PARTICIPANT_MISMATCH_GRACE_MS);
+
+      expect(warnSpy).not.toHaveBeenCalled();
+    });
+
+    it('clears grace timer on dispose', () => {
+      const warnSpy = jest.spyOn(wxAppDiagnosticLogging, 'logWxAppOfferParticipantMismatch');
+      const observability = new WxAppOfferObservability();
+      const ctx = makeContext();
+
+      observability.handleUiControlsUpdate(ctx);
+      observability.dispose();
+
+      jest.advanceTimersByTime(WXAPP_PARTICIPANT_MISMATCH_GRACE_MS);
+
+      expect(warnSpy).not.toHaveBeenCalled();
+    });
+
+    it('does not reschedule diagnostics after dispose', () => {
+      const logSpy = jest.spyOn(wxAppDiagnosticLogging, 'logWxAppOfferDecision');
+      const warnSpy = jest.spyOn(wxAppDiagnosticLogging, 'logWxAppOfferParticipantMismatch');
+      const observability = new WxAppOfferObservability();
+      const ctx = makeContext();
+
+      observability.dispose();
+      observability.handleUiControlsUpdate(ctx);
+      jest.advanceTimersByTime(WXAPP_PARTICIPANT_MISMATCH_GRACE_MS);
+
+      expect(logSpy).not.toHaveBeenCalled();
+      expect(warnSpy).not.toHaveBeenCalled();
+      expect(ctx.getMetricsManager().trackEvent).not.toHaveBeenCalledWith(
+        METRIC_EVENT_NAMES.WXAPP_OFFER_PARTICIPANT_FIELDS_MISSING,
+        expect.anything(),
+        expect.anything()
+      );
+    });
+
+    it('does not warn or emit metric for outdial offers with missing wxApp fields', () => {
+      const warnSpy = jest.spyOn(wxAppDiagnosticLogging, 'logWxAppOfferParticipantMismatch');
+      const observability = new WxAppOfferObservability();
+      const ctx = makeContext({isOutdial: true});
+
+      observability.handleUiControlsUpdate(ctx);
+      jest.advanceTimersByTime(WXAPP_PARTICIPANT_MISMATCH_GRACE_MS);
+
+      expect(warnSpy).not.toHaveBeenCalled();
+      expect(ctx.getMetricsManager().trackEvent).not.toHaveBeenCalledWith(
+        METRIC_EVENT_NAMES.WXAPP_OFFER_PARTICIPANT_FIELDS_MISSING,
+        expect.anything(),
+        expect.anything()
+      );
+    });
+
+    it('does not schedule mismatch while usersub is unpublished, then emits after refresh when usersub becomes active', () => {
+      const warnSpy = jest.spyOn(wxAppDiagnosticLogging, 'logWxAppOfferParticipantMismatch');
+      const observability = new WxAppOfferObservability();
+      const ctx = makeContext({usersubPublished: false});
+
+      observability.handleUiControlsUpdate(ctx);
+      jest.advanceTimersByTime(WXAPP_PARTICIPANT_MISMATCH_GRACE_MS);
+      expect(warnSpy).not.toHaveBeenCalled();
+
+      ctx.setUsersubPublished(true);
+      observability.handleUiControlsUpdate(ctx);
+      expect(warnSpy).not.toHaveBeenCalled();
+
+      jest.advanceTimersByTime(WXAPP_PARTICIPANT_MISMATCH_GRACE_MS);
+
+      expect(warnSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          usersubPublished: true,
+          hasDeviceCallId: false,
+          hasDeviceId: false,
+        })
+      );
+      expect(ctx.getMetricsManager().trackEvent).toHaveBeenCalledWith(
+        METRIC_EVENT_NAMES.WXAPP_OFFER_PARTICIPANT_FIELDS_MISSING,
+        expect.objectContaining({
+          usersubPublished: true,
+          hasDeviceCallId: false,
+          hasDeviceId: false,
+        }),
+        ['operational', 'behavioral']
+      );
+    });
+
+    it('does not emit mismatch after usersub refresh when participant fields are already valid', () => {
+      const warnSpy = jest.spyOn(wxAppDiagnosticLogging, 'logWxAppOfferParticipantMismatch');
+      const observability = new WxAppOfferObservability();
+      const ctx = makeContext({
+        taskData: makeTaskDataWithWxAppFields(),
+        usersubPublished: false,
+      });
+
+      observability.handleUiControlsUpdate(ctx);
+      ctx.setUsersubPublished(true);
+      observability.handleUiControlsUpdate(ctx);
+      jest.advanceTimersByTime(WXAPP_PARTICIPANT_MISMATCH_GRACE_MS);
+
+      expect(warnSpy).not.toHaveBeenCalled();
+      expect(ctx.getMetricsManager().trackEvent).not.toHaveBeenCalledWith(
+        METRIC_EVENT_NAMES.WXAPP_OFFER_PARTICIPANT_FIELDS_MISSING,
+        expect.anything(),
+        expect.anything()
+      );
+    });
+  });
+});

package/test/unit/spec/services/task/voice/wxAppVoiceMethods.ts

@@ -431,7 +431,12 @@ describe('runWxAppAccept', () => {
     ]);
     expect(deps.metricsManager.trackEvent).toHaveBeenCalledWith(
       METRIC_EVENT_NAMES.WXAPP_TASK_ACCEPT_SUCCESS,
-      {taskId: 'interaction-1'},
+      expect.objectContaining({
+        taskId: 'interaction-1',
+        acceptReason: 'wxApp_offer_ready',
+        hasDeviceCallId: true,
+        hasDeviceId: true,
+      }),
       ['operational', 'behavioral']
     );
     expect(lifecycle.setWxAppAcceptInFlight).toHaveBeenNthCalledWith(1, true);
@@ -455,6 +460,7 @@ describe('runWxAppAccept', () => {
       expect.objectContaining({
         taskId: 'interaction-1',
         trackingId: 'track-1',
+        acceptReason: 'wxApp_offer_ready',
       }),
       ['operational', 'behavioral']
     );
@@ -462,6 +468,42 @@ describe('runWxAppAccept', () => {
     expect(lifecycle.mapWxAppVoiceError).toHaveBeenCalledWith(error, METHODS.ACCEPT);
     expect(lifecycle.setWxAppAcceptInFlight).toHaveBeenLastCalledWith(false);
   });
+
+  it('includes captured acceptReason on accept success when pending', async () => {
+    const deps = makeDeps();
+    const lifecycle = makeLifecycle();
+
+    await runWxAppAccept(deps, lifecycle, {acceptReason: 'wxApp_answer_pending'});
+
+    expect(deps.metricsManager.trackEvent).toHaveBeenCalledWith(
+      METRIC_EVENT_NAMES.WXAPP_TASK_ACCEPT_SUCCESS,
+      expect.objectContaining({
+        taskId: 'interaction-1',
+        acceptReason: 'wxApp_answer_pending',
+      }),
+      ['operational', 'behavioral']
+    );
+  });
+
+  it('includes captured acceptReason on accept failure when pending', async () => {
+    const deps = makeDeps();
+    const error = new Error('answer failed');
+    deps.answerCallOnWebexService!.answerCall = jest.fn().mockRejectedValue(error);
+    const lifecycle = makeLifecycle();
+
+    await expect(
+      runWxAppAccept(deps, lifecycle, {acceptReason: 'wxApp_answer_pending'})
+    ).rejects.toThrow('answer failed');
+
+    expect(deps.metricsManager.trackEvent).toHaveBeenCalledWith(
+      METRIC_EVENT_NAMES.WXAPP_TASK_ACCEPT_FAILED,
+      expect.objectContaining({
+        taskId: 'interaction-1',
+        acceptReason: 'wxApp_answer_pending',
+      }),
+      ['operational', 'behavioral']
+    );
+  });
 });
 
 describe('runWxAppReject', () => {
@@ -473,7 +515,12 @@ describe('runWxAppReject', () => {
 
     expect(deps.metricsManager.trackEvent).toHaveBeenCalledWith(
       METRIC_EVENT_NAMES.WXAPP_TASK_DECLINE_SUCCESS,
-      {taskId: 'interaction-1'},
+      expect.objectContaining({
+        taskId: 'interaction-1',
+        acceptReason: 'wxApp_offer_ready',
+        hasDeviceCallId: true,
+        hasDeviceId: true,
+      }),
       ['operational', 'behavioral']
     );
   });
@@ -488,11 +535,50 @@ describe('runWxAppReject', () => {
 
     expect(deps.metricsManager.trackEvent).toHaveBeenCalledWith(
       METRIC_EVENT_NAMES.WXAPP_TASK_DECLINE_FAILED,
-      expect.objectContaining({taskId: 'interaction-1'}),
+      expect.objectContaining({
+        taskId: 'interaction-1',
+        acceptReason: 'wxApp_offer_ready',
+      }),
       ['operational', 'behavioral']
     );
     expect(lifecycle.mapWxAppVoiceError).toHaveBeenCalledWith(error, METHODS.REJECT);
   });
+
+  it('includes captured acceptReason on decline success when pending', async () => {
+    const deps = makeDeps();
+    const lifecycle = makeLifecycle();
+
+    await runWxAppReject(deps, lifecycle, {acceptReason: 'wxApp_answer_pending'});
+
+    expect(deps.metricsManager.trackEvent).toHaveBeenCalledWith(
+      METRIC_EVENT_NAMES.WXAPP_TASK_DECLINE_SUCCESS,
+      expect.objectContaining({
+        taskId: 'interaction-1',
+        acceptReason: 'wxApp_answer_pending',
+      }),
+      ['operational', 'behavioral']
+    );
+  });
+
+  it('includes captured acceptReason on decline failure when pending', async () => {
+    const deps = makeDeps();
+    const error = new Error('reject failed');
+    deps.answerCallOnWebexService!.rejectCall = jest.fn().mockRejectedValue(error);
+    const lifecycle = makeLifecycle();
+
+    await expect(
+      runWxAppReject(deps, lifecycle, {acceptReason: 'wxApp_answer_pending'})
+    ).rejects.toThrow('reject failed');
+
+    expect(deps.metricsManager.trackEvent).toHaveBeenCalledWith(
+      METRIC_EVENT_NAMES.WXAPP_TASK_DECLINE_FAILED,
+      expect.objectContaining({
+        taskId: 'interaction-1',
+        acceptReason: 'wxApp_answer_pending',
+      }),
+      ['operational', 'behavioral']
+    );
+  });
 });
 
 describe('runWxAppOutdialDecline', () => {
@@ -509,7 +595,30 @@ describe('runWxAppOutdialDecline', () => {
     ]);
     expect(deps.metricsManager.trackEvent).toHaveBeenCalledWith(
       METRIC_EVENT_NAMES.WXAPP_TASK_DECLINE_SUCCESS,
-      {taskId: 'interaction-1'},
+      expect.objectContaining({
+        taskId: 'interaction-1',
+        acceptReason: 'wxApp_offer_ready',
+        hasDeviceCallId: true,
+        hasDeviceId: true,
+      }),
+      ['operational', 'behavioral']
+    );
+  });
+
+  it('tracks post-accept acceptReason on outdial cancel when provided', async () => {
+    const deps = makeDeps();
+    const cancelResult = {type: 'RoutingMessage', trackingId: 'track-1', data: {}};
+
+    await runWxAppOutdialDecline(deps, async () => cancelResult, {
+      acceptReason: 'wxApp_answer_pending',
+    });
+
+    expect(deps.metricsManager.trackEvent).toHaveBeenCalledWith(
+      METRIC_EVENT_NAMES.WXAPP_TASK_DECLINE_SUCCESS,
+      expect.objectContaining({
+        taskId: 'interaction-1',
+        acceptReason: 'wxApp_answer_pending',
+      }),
       ['operational', 'behavioral']
     );
   });
@@ -555,6 +664,8 @@ describe('runWxAppOutdialDecline', () => {
         trackingId: 'aqm-track-1',
         failureReason: 'TASK_NOT_FOUND',
         reasonCode: 404,
+        hasDeviceCallId: true,
+        hasDeviceId: true,
       }),
       ['operational', 'behavioral']
     );
@@ -596,7 +707,12 @@ describe('runWxAppTransmitDtmf metrics', () => {
 
     expect(deps.metricsManager.trackEvent).toHaveBeenCalledWith(
       METRIC_EVENT_NAMES.WXAPP_TASK_DTMF_SUCCESS,
-      {taskId: 'interaction-1', dtmfLength: 3},
+      expect.objectContaining({
+        taskId: 'interaction-1',
+        dtmfLength: 3,
+        hasDeviceCallId: true,
+        hasDeviceId: true,
+      }),
       ['operational', 'behavioral']
     );
   });