@webex/contact-center 3.12.0-llmrefactor.8 → 3.12.0-llmrefactor.9

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

@@ -4,6 +4,7 @@ import {
   TaskData,
   CONSULT_TRANSFER_DESTINATION_TYPE,
   TASK_EVENTS,
+  VOICE_VARIANT,
 } from '../../../../../../src/services/task/types';
 import {CC_EVENTS} from '../../../../../../src/services/config/types';
 import {TaskEvent, TaskState} from '../../../../../../src/services/task/state-machine';
@@ -12,6 +13,7 @@ import * as Utils from '../../../../../../src/services/core/Utils';
 import {createTaskData} from '../taskTestUtils';
 import MetricsManager from '../../../../../../src/metrics/MetricsManager';
 import {METRIC_EVENT_NAMES} from '../../../../../../src/metrics/constants';
+import * as wxAppDiagnosticLogging from '../../../../../../src/services/wxAppDiagnosticLogging';
 
 jest.mock('../../../../../../src/services/core/WebexRequest', () => ({
   __esModule: true,
@@ -846,6 +848,73 @@ 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', () => {
+      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'},
+          },
+        } as any,
+      });
+      const voice = new Voice(dummyContact, taskData, {
+        enableWxBetterTogether: true,
+        voiceVariant: VOICE_VARIANT.WEBRTC,
+      });
+
+      voice.stateMachineService?.send({type: TaskEvent.TASK_INCOMING, taskData});
+
+      expect(logSpy).toHaveBeenCalledWith(
+        expect.objectContaining({acceptReason: 'browser_webrtc_offer'})
+      );
+    });
+  });
+
   describe('applyWxAppMuteStateFromSync', () => {
     const wxAppParticipant = {
       deviceType: 'wxApp',
@@ -1305,6 +1374,66 @@ describe('Voice Task', () => {
       expect(dummyContact.cancelTask).toHaveBeenCalledWith({interactionId: 'int1'});
     });
 
+    it('emits TASK_DECLINE and WXAPP_TASK_DECLINE success metrics for wxApp outdial decline', async () => {
+      const taskData = makeWxAppOutdialTaskData();
+      const voice = new Voice(dummyContact, taskData, {enableWxBetterTogether: true});
+      voice.stateMachineService?.send({type: TaskEvent.TASK_INCOMING, taskData});
+      const metricsManager = MetricsManager.getInstance();
+      const trackEventSpy = jest.spyOn(metricsManager, 'trackEvent');
+
+      await voice.decline();
+
+      expect(trackEventSpy).toHaveBeenCalledWith(
+        METRIC_EVENT_NAMES.WXAPP_TASK_DECLINE_SUCCESS,
+        expect.objectContaining({taskId: 'int1'}),
+        ['operational', 'behavioral']
+      );
+      expect(trackEventSpy).toHaveBeenCalledWith(
+        METRIC_EVENT_NAMES.TASK_DECLINE_SUCCESS,
+        expect.objectContaining({taskId: 'int1'}),
+        ['operational', 'behavioral']
+      );
+    });
+
+    it('emits TASK_DECLINE and WXAPP_TASK_DECLINE failed metrics when outdial cancel fails', async () => {
+      const cancelError = Object.assign(new Error('AQM failed'), {
+        details: {
+          trackingId: 'aqm-track-1',
+          orgId: 'org-1',
+          type: 'Service.aqm.task.cancel',
+          data: {reason: 'TASK_NOT_FOUND', reasonCode: 404, agentId: 'agent-1'},
+        },
+      });
+      dummyContact.cancelTask = jest.fn().mockRejectedValue(cancelError);
+      const taskData = makeWxAppOutdialTaskData();
+      const voice = new Voice(dummyContact, taskData, {enableWxBetterTogether: true});
+      voice.stateMachineService?.send({type: TaskEvent.TASK_INCOMING, taskData});
+      const metricsManager = MetricsManager.getInstance();
+      const trackEventSpy = jest.spyOn(metricsManager, 'trackEvent');
+
+      await expect(voice.decline()).rejects.toThrow('AQM failed');
+
+      expect(trackEventSpy).toHaveBeenCalledWith(
+        METRIC_EVENT_NAMES.WXAPP_TASK_DECLINE_FAILED,
+        expect.objectContaining({
+          taskId: 'int1',
+          trackingId: 'aqm-track-1',
+          failureReason: 'TASK_NOT_FOUND',
+        }),
+        ['operational', 'behavioral']
+      );
+      expect(trackEventSpy).toHaveBeenCalledWith(
+        METRIC_EVENT_NAMES.TASK_DECLINE_FAILED,
+        expect.objectContaining({
+          taskId: 'int1',
+          trackingId: 'aqm-track-1',
+          failureReason: 'TASK_NOT_FOUND',
+        }),
+        ['operational', 'behavioral']
+      );
+      dummyContact.cancelTask = jest.fn().mockResolvedValue(undefined);
+    });
+
     it('clears wxAppAnswerPending when declining outdial', async () => {
       const mockSvc = {
         answerCall: jest.fn().mockResolvedValue(undefined),
@@ -1456,6 +1585,13 @@ describe('Voice Task', () => {
       const firstToggle = voice.toggleMute();
       const secondToggle = voice.toggleMute();
 
+      await new Promise<void>((resolve) => {
+        setImmediate(resolve);
+      });
+
+      expect(mockSvc.muteCall).toHaveBeenCalledTimes(1);
+      expect(mockSvc.unmuteCall).not.toHaveBeenCalled();
+
       resolveMute!();
       await Promise.all([firstToggle, secondToggle]);
 
@@ -1464,6 +1600,96 @@ describe('Voice Task', () => {
       expect(voice.getWxAppMuted()).toBe(false);
     });
 
+    it('queues three concurrent no-arg toggleMute() calls in order', async () => {
+      let resolveFirstMute: () => void;
+      const firstMuteGate = new Promise<void>((resolve) => {
+        resolveFirstMute = resolve;
+      });
+      const mockSvc = {
+        muteCall: jest
+          .fn()
+          .mockImplementationOnce(() => firstMuteGate)
+          .mockResolvedValue(undefined),
+        unmuteCall: jest.fn().mockResolvedValue(undefined),
+      };
+      const taskData = createBaseData({
+        agentId: 'agent-1',
+        interaction: {
+          participants: {
+            'agent-1': {id: 'agent-1', ...wxAppParticipant},
+          },
+        } as any,
+      });
+      const voice = new Voice(dummyContact, taskData, {
+        enableWxBetterTogether: true,
+        answerCallOnWebexService: mockSvc as any,
+      });
+      primeConnectedState(voice, taskData);
+      expect(voice.getWxAppMuted()).toBe(false);
+
+      const firstToggle = voice.toggleMute();
+      const secondToggle = voice.toggleMute();
+      const thirdToggle = voice.toggleMute();
+
+      await new Promise<void>((resolve) => {
+        setImmediate(resolve);
+      });
+
+      expect(mockSvc.muteCall).toHaveBeenCalledTimes(1);
+      expect(mockSvc.unmuteCall).not.toHaveBeenCalled();
+
+      resolveFirstMute!();
+      await Promise.all([firstToggle, secondToggle, thirdToggle]);
+
+      expect(mockSvc.muteCall).toHaveBeenCalledTimes(2);
+      expect(mockSvc.unmuteCall).toHaveBeenCalledTimes(1);
+      expect(voice.getWxAppMuted()).toBe(true);
+    });
+
+    it('records duration_ms on each serialized toggleMute success metric', async () => {
+      let resolveFirstMute: () => void;
+      const firstMuteGate = new Promise<void>((resolve) => {
+        resolveFirstMute = resolve;
+      });
+      const mockSvc = {
+        muteCall: jest.fn().mockImplementationOnce(() => firstMuteGate),
+        unmuteCall: jest.fn().mockResolvedValue(undefined),
+      };
+      const taskData = createBaseData({
+        agentId: 'agent-1',
+        interaction: {
+          participants: {
+            'agent-1': {id: 'agent-1', ...wxAppParticipant},
+          },
+        } as any,
+      });
+      const voice = new Voice(dummyContact, taskData, {
+        enableWxBetterTogether: true,
+        answerCallOnWebexService: mockSvc as any,
+      });
+      primeConnectedState(voice, taskData);
+      const metricsManager = MetricsManager.getInstance();
+      const trackEventSpy = jest.spyOn(metricsManager, 'trackEvent');
+
+      const firstToggle = voice.toggleMute();
+      const secondToggle = voice.toggleMute();
+
+      resolveFirstMute!();
+      await Promise.all([firstToggle, secondToggle]);
+
+      const successCalls = trackEventSpy.mock.calls.filter(
+        ([eventName]) => eventName === METRIC_EVENT_NAMES.WXAPP_TASK_MUTE_SUCCESS
+      );
+      expect(successCalls).toHaveLength(2);
+      successCalls.forEach(([, payload]) => {
+        expect(payload).toEqual(
+          expect.objectContaining({
+            duration_ms: expect.any(Number),
+          })
+        );
+      });
+    });
+
     it('continues queued toggleMute after predecessor failure', async () => {
       const mockSvc = {
         muteCall: jest.fn().mockRejectedValue(new Error('mute failed')),
@@ -1519,5 +1745,159 @@ describe('Voice Task', () => {
         lineOwnerId: undefined,
       });
     });
+
+    it('serializes concurrent transmitDtmf() so each digit completes before the next', async () => {
+      let resolveFirst: () => void;
+      const firstGate = new Promise<void>((resolve) => {
+        resolveFirst = resolve;
+      });
+      const mockSvc = {
+        transmitDtmf: jest
+          .fn()
+          .mockImplementationOnce(() => firstGate)
+          .mockResolvedValueOnce(undefined),
+      };
+      const taskData = createBaseData({
+        agentId: 'agent-1',
+        interaction: {
+          participants: {
+            'agent-1': {id: 'agent-1', ...wxAppParticipant},
+          },
+        } as any,
+      });
+      const voice = new Voice(dummyContact, taskData, {
+        enableWxBetterTogether: true,
+        answerCallOnWebexService: mockSvc as any,
+      });
+      primeConnectedState(voice, taskData);
+
+      const firstDtmf = voice.transmitDtmf({dtmf: '1'});
+      const secondDtmf = voice.transmitDtmf({dtmf: '2'});
+
+      await new Promise<void>((resolve) => {
+        setImmediate(resolve);
+      });
+
+      expect(mockSvc.transmitDtmf).toHaveBeenCalledTimes(1);
+      expect(mockSvc.transmitDtmf).toHaveBeenCalledWith({
+        callId: 'call-id-1',
+        dtmf: '1',
+        lineOwnerId: undefined,
+      });
+
+      resolveFirst!();
+      await Promise.all([firstDtmf, secondDtmf]);
+
+      expect(mockSvc.transmitDtmf).toHaveBeenCalledTimes(2);
+      expect(mockSvc.transmitDtmf).toHaveBeenNthCalledWith(2, {
+        callId: 'call-id-1',
+        dtmf: '2',
+        lineOwnerId: undefined,
+      });
+    });
+
+    it('queues three concurrent transmitDtmf() calls in order', async () => {
+      let resolveFirst: () => void;
+      const firstGate = new Promise<void>((resolve) => {
+        resolveFirst = resolve;
+      });
+      const mockSvc = {
+        transmitDtmf: jest
+          .fn()
+          .mockImplementationOnce(() => firstGate)
+          .mockResolvedValue(undefined),
+      };
+      const taskData = createBaseData({
+        agentId: 'agent-1',
+        interaction: {
+          participants: {
+            'agent-1': {id: 'agent-1', ...wxAppParticipant},
+          },
+        } as any,
+      });
+      const voice = new Voice(dummyContact, taskData, {
+        enableWxBetterTogether: true,
+        answerCallOnWebexService: mockSvc as any,
+      });
+      primeConnectedState(voice, taskData);
+
+      const firstDtmf = voice.transmitDtmf({dtmf: '1'});
+      const secondDtmf = voice.transmitDtmf({dtmf: '2'});
+      const thirdDtmf = voice.transmitDtmf({dtmf: '3'});
+
+      await new Promise<void>((resolve) => {
+        setImmediate(resolve);
+      });
+
+      expect(mockSvc.transmitDtmf).toHaveBeenCalledTimes(1);
+      expect(mockSvc.transmitDtmf).toHaveBeenCalledWith({
+        callId: 'call-id-1',
+        dtmf: '1',
+        lineOwnerId: undefined,
+      });
+
+      resolveFirst!();
+      await Promise.all([firstDtmf, secondDtmf, thirdDtmf]);
+
+      expect(mockSvc.transmitDtmf).toHaveBeenCalledTimes(3);
+      expect(mockSvc.transmitDtmf).toHaveBeenNthCalledWith(2, {
+        callId: 'call-id-1',
+        dtmf: '2',
+        lineOwnerId: undefined,
+      });
+      expect(mockSvc.transmitDtmf).toHaveBeenNthCalledWith(3, {
+        callId: 'call-id-1',
+        dtmf: '3',
+        lineOwnerId: undefined,
+      });
+    });
+
+    it('records duration_ms on each serialized transmitDtmf success metric', async () => {
+      let resolveFirst: () => void;
+      const firstGate = new Promise<void>((resolve) => {
+        resolveFirst = resolve;
+      });
+      const mockSvc = {
+        transmitDtmf: jest
+          .fn()
+          .mockImplementationOnce(() => firstGate)
+          .mockResolvedValueOnce(undefined),
+      };
+      const taskData = createBaseData({
+        agentId: 'agent-1',
+        interaction: {
+          participants: {
+            'agent-1': {id: 'agent-1', ...wxAppParticipant},
+          },
+        } as any,
+      });
+      const voice = new Voice(dummyContact, taskData, {
+        enableWxBetterTogether: true,
+        answerCallOnWebexService: mockSvc as any,
+      });
+      primeConnectedState(voice, taskData);
+      const metricsManager = MetricsManager.getInstance();
+      const trackEventSpy = jest.spyOn(metricsManager, 'trackEvent');
+
+      const firstDtmf = voice.transmitDtmf({dtmf: '1'});
+      const secondDtmf = voice.transmitDtmf({dtmf: '2'});
+
+      resolveFirst!();
+      await Promise.all([firstDtmf, secondDtmf]);
+
+      const successCalls = trackEventSpy.mock.calls.filter(
+        ([eventName]) => eventName === METRIC_EVENT_NAMES.WXAPP_TASK_DTMF_SUCCESS
+      );
+      expect(successCalls).toHaveLength(2);
+      successCalls.forEach(([, payload]) => {
+        expect(payload).toEqual(
+          expect.objectContaining({
+            duration_ms: expect.any(Number),
+          })
+        );
+      });
+
+      trackEventSpy.mockRestore();
+    });
   });
 });

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

@@ -8,7 +8,10 @@ import {
   toggleMuteOnWebex,
   transmitDtmfOnWebex,
   runWxAppAccept,
+  runWxAppOutdialDecline,
   runWxAppReject,
+  runWxAppToggleMute,
+  runWxAppTransmitDtmf,
   mapWxAppVoiceError,
   WxAppVoiceDeps,
   WxAppVoiceLifecycle,
@@ -17,6 +20,8 @@ import {METHODS} from '../../../../../../src/constants';
 import {TaskState} from '../../../../../../src/services/task/state-machine';
 import {TaskData} from '../../../../../../src/services/task/types';
 import AnswerCallOnWebexService from '../../../../../../src/services/AnswerCallOnWebexService';
+import MetricsManager from '../../../../../../src/metrics/MetricsManager';
+import {METRIC_EVENT_NAMES} from '../../../../../../src/metrics/constants';
 
 const WX_APP_DEVICE = {
   deviceType: 'wxApp',
@@ -53,6 +58,13 @@ function makeMockService(): jest.Mocked<AnswerCallOnWebexService> {
   } as unknown as jest.Mocked<AnswerCallOnWebexService>;
 }
 
+function makeMockMetricsManager(): jest.Mocked<Pick<MetricsManager, 'timeEvent' | 'trackEvent'>> {
+  return {
+    timeEvent: jest.fn(),
+    trackEvent: jest.fn(),
+  };
+}
+
 function makeDeps(overrides: Partial<WxAppVoiceDeps> = {}): WxAppVoiceDeps {
   let muted = false;
 
@@ -60,6 +72,7 @@ function makeDeps(overrides: Partial<WxAppVoiceDeps> = {}): WxAppVoiceDeps {
     enableWxBetterTogether: true,
     answerCallOnWebexService: makeMockService(),
     agentId: 'agent-1',
+    metricsManager: makeMockMetricsManager() as unknown as MetricsManager,
     getTaskData: () => makeTaskData(),
     getTaskState: () => TaskState.OFFERED,
     getWxAppMuted: () => muted,
@@ -412,6 +425,15 @@ describe('runWxAppAccept', () => {
 
     await runWxAppAccept(deps, lifecycle);
 
+    expect(deps.metricsManager.timeEvent).toHaveBeenCalledWith([
+      METRIC_EVENT_NAMES.WXAPP_TASK_ACCEPT_SUCCESS,
+      METRIC_EVENT_NAMES.WXAPP_TASK_ACCEPT_FAILED,
+    ]);
+    expect(deps.metricsManager.trackEvent).toHaveBeenCalledWith(
+      METRIC_EVENT_NAMES.WXAPP_TASK_ACCEPT_SUCCESS,
+      {taskId: 'interaction-1'},
+      ['operational', 'behavioral']
+    );
     expect(lifecycle.setWxAppAcceptInFlight).toHaveBeenNthCalledWith(1, true);
     expect(lifecycle.setWxAppAnswerPending).toHaveBeenCalledWith(true);
     expect(deps.answerCallOnWebexService!.answerCall).toHaveBeenCalled();
@@ -422,12 +444,20 @@ describe('runWxAppAccept', () => {
 
   it('clears pending and maps error when answer fails', async () => {
     const deps = makeDeps();
-    const error = new Error('answer failed');
+    const error = Object.assign(new Error('answer failed'), {trackingId: 'track-1'});
     deps.answerCallOnWebexService!.answerCall = jest.fn().mockRejectedValue(error);
     const lifecycle = makeLifecycle();
 
     await expect(runWxAppAccept(deps, lifecycle)).rejects.toThrow('answer failed');
 
+    expect(deps.metricsManager.trackEvent).toHaveBeenCalledWith(
+      METRIC_EVENT_NAMES.WXAPP_TASK_ACCEPT_FAILED,
+      expect.objectContaining({
+        taskId: 'interaction-1',
+        trackingId: 'track-1',
+      }),
+      ['operational', 'behavioral']
+    );
     expect(lifecycle.setWxAppAnswerPending).toHaveBeenCalledWith(false);
     expect(lifecycle.mapWxAppVoiceError).toHaveBeenCalledWith(error, METHODS.ACCEPT);
     expect(lifecycle.setWxAppAcceptInFlight).toHaveBeenLastCalledWith(false);
@@ -435,6 +465,19 @@ describe('runWxAppAccept', () => {
 });
 
 describe('runWxAppReject', () => {
+  it('tracks wxApp decline success metric', async () => {
+    const deps = makeDeps();
+    const lifecycle = makeLifecycle();
+
+    await runWxAppReject(deps, lifecycle);
+
+    expect(deps.metricsManager.trackEvent).toHaveBeenCalledWith(
+      METRIC_EVENT_NAMES.WXAPP_TASK_DECLINE_SUCCESS,
+      {taskId: 'interaction-1'},
+      ['operational', 'behavioral']
+    );
+  });
+
   it('maps error when reject fails', async () => {
     const deps = makeDeps();
     const error = new Error('reject failed');
@@ -443,10 +486,81 @@ describe('runWxAppReject', () => {
 
     await expect(runWxAppReject(deps, lifecycle)).rejects.toThrow('reject failed');
 
+    expect(deps.metricsManager.trackEvent).toHaveBeenCalledWith(
+      METRIC_EVENT_NAMES.WXAPP_TASK_DECLINE_FAILED,
+      expect.objectContaining({taskId: 'interaction-1'}),
+      ['operational', 'behavioral']
+    );
     expect(lifecycle.mapWxAppVoiceError).toHaveBeenCalledWith(error, METHODS.REJECT);
   });
 });
 
+describe('runWxAppOutdialDecline', () => {
+  it('tracks wxApp decline success metric for outdial cancel', async () => {
+    const deps = makeDeps();
+    const cancelResult = {type: 'RoutingMessage', trackingId: 'track-1', data: {}};
+
+    const result = await runWxAppOutdialDecline(deps, async () => cancelResult);
+
+    expect(result).toBe(cancelResult);
+    expect(deps.metricsManager.timeEvent).toHaveBeenCalledWith([
+      METRIC_EVENT_NAMES.WXAPP_TASK_DECLINE_SUCCESS,
+      METRIC_EVENT_NAMES.WXAPP_TASK_DECLINE_FAILED,
+    ]);
+    expect(deps.metricsManager.trackEvent).toHaveBeenCalledWith(
+      METRIC_EVENT_NAMES.WXAPP_TASK_DECLINE_SUCCESS,
+      {taskId: 'interaction-1'},
+      ['operational', 'behavioral']
+    );
+  });
+
+  it('tracks wxApp decline failed metric and rethrows when cancel fails', async () => {
+    const deps = makeDeps();
+    const error = new Error('cancel failed');
+
+    await expect(
+      runWxAppOutdialDecline(deps, async () => {
+        throw error;
+      })
+    ).rejects.toThrow('cancel failed');
+
+    expect(deps.metricsManager.trackEvent).toHaveBeenCalledWith(
+      METRIC_EVENT_NAMES.WXAPP_TASK_DECLINE_FAILED,
+      expect.objectContaining({taskId: 'interaction-1'}),
+      ['operational', 'behavioral']
+    );
+  });
+
+  it('preserves AQM correlation fields when cancel fails with error.details', async () => {
+    const deps = makeDeps();
+    const error = Object.assign(new Error('AQM failed'), {
+      details: {
+        trackingId: 'aqm-track-1',
+        orgId: 'org-1',
+        type: 'Service.aqm.task.cancel',
+        data: {reason: 'TASK_NOT_FOUND', reasonCode: 404, agentId: 'agent-1'},
+      },
+    });
+
+    await expect(
+      runWxAppOutdialDecline(deps, async () => {
+        throw error;
+      })
+    ).rejects.toThrow('AQM failed');
+
+    expect(deps.metricsManager.trackEvent).toHaveBeenCalledWith(
+      METRIC_EVENT_NAMES.WXAPP_TASK_DECLINE_FAILED,
+      expect.objectContaining({
+        taskId: 'interaction-1',
+        trackingId: 'aqm-track-1',
+        failureReason: 'TASK_NOT_FOUND',
+        reasonCode: 404,
+      }),
+      ['operational', 'behavioral']
+    );
+  });
+});
+
 describe('mapWxAppVoiceError', () => {
   it('rethrows normalized wxApp telephony errors without remapping', () => {
     const normalized = Object.assign(new Error('TELEPHONY_ERROR'), {
@@ -457,3 +571,33 @@ describe('mapWxAppVoiceError', () => {
     expect(() => mapWxAppVoiceError(normalized, 'accept', 'cc')).toThrow(normalized);
   });
 });
+
+describe('runWxAppToggleMute metrics', () => {
+  it('tracks mute success metric', async () => {
+    const deps = makeDeps({getTaskState: () => TaskState.CONNECTED});
+    const lifecycle = makeLifecycle();
+
+    await runWxAppToggleMute(deps, lifecycle);
+
+    expect(deps.metricsManager.trackEvent).toHaveBeenCalledWith(
+      METRIC_EVENT_NAMES.WXAPP_TASK_MUTE_SUCCESS,
+      expect.objectContaining({taskId: 'interaction-1', targetMuted: true}),
+      ['operational', 'behavioral']
+    );
+  });
+});
+
+describe('runWxAppTransmitDtmf metrics', () => {
+  it('tracks dtmf success metric with digit length only', async () => {
+    const deps = makeDeps({getTaskState: () => TaskState.CONNECTED});
+    const lifecycle = makeLifecycle();
+
+    await runWxAppTransmitDtmf(deps, lifecycle, {dtmf: '123'});
+
+    expect(deps.metricsManager.trackEvent).toHaveBeenCalledWith(
+      METRIC_EVENT_NAMES.WXAPP_TASK_DTMF_SUCCESS,
+      {taskId: 'interaction-1', dtmfLength: 3},
+      ['operational', 'behavioral']
+    );
+  });
+});