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

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']
     );
   });

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

@@ -3,13 +3,15 @@ import {
   callIdSuffix,
   deriveWxAppAcceptReason,
   logWxAppOfferDecision,
+  logWxAppOfferParticipantMismatch,
   logWxAppSessionReadiness,
   logWxAppTelephonyAction,
   WXAPP_LOG_PREFIX,
 } from '../../../../src/services/wxAppDiagnosticLogging';
 
 jest.mock('../../../../src/logger-proxy', () => ({
-  info: jest.fn(),
+  log: jest.fn(),
+  warn: jest.fn(),
   error: jest.fn(),
 }));
 
@@ -76,7 +78,7 @@ describe('wxAppDiagnosticLogging', () => {
   });
 
   describe('log helpers', () => {
-    it('logs session readiness with feature prefix', () => {
+    it('logs session readiness at log level with grep-friendly suffix', () => {
       logWxAppSessionReadiness({
         enableWxBetterTogether: true,
         loginOption: 'EXTENSION',
@@ -86,8 +88,8 @@ describe('wxAppDiagnosticLogging', () => {
         telephonyTaskType: 'Voice',
       });
 
-      expect(LoggerProxy.info).toHaveBeenCalledWith(
-        `${WXAPP_LOG_PREFIX} session readiness`,
+      expect(LoggerProxy.log).toHaveBeenCalledWith(
+        expect.stringContaining(`${WXAPP_LOG_PREFIX} session readiness`),
         expect.objectContaining({
           module: 'wxAppDiagnosticLogging',
           method: 'logWxAppSessionReadiness',
@@ -95,27 +97,61 @@ describe('wxAppDiagnosticLogging', () => {
             feature: 'wxApp',
             event: 'session_readiness',
             loginOption: 'EXTENSION',
+            usersubPublished: true,
+            mercurySubscribed: true,
           }),
         })
       );
+      expect(LoggerProxy.log).toHaveBeenCalledWith(
+        expect.stringContaining('usersubPublished=true'),
+        expect.anything()
+      );
     });
 
-    it('logs offer decision with acceptReason', () => {
+    it('logs offer decision at log level with acceptReason suffix', () => {
       logWxAppOfferDecision({
         interactionId: 'task-1',
         acceptVisible: true,
         acceptEnabled: false,
         acceptReason: 'extension_non_wxApp_offer',
         hasDeviceCallId: false,
+        hasDeviceId: false,
+        usersubPublished: true,
       });
 
-      expect(LoggerProxy.info).toHaveBeenCalledWith(
-        `${WXAPP_LOG_PREFIX} offer decision`,
+      expect(LoggerProxy.log).toHaveBeenCalledWith(
+        expect.stringContaining('acceptReason=extension_non_wxApp_offer'),
         expect.objectContaining({
           data: expect.objectContaining({
             event: 'offer_decision',
             acceptReason: 'extension_non_wxApp_offer',
             interactionId: 'task-1',
+            usersubPublished: true,
+          }),
+        })
+      );
+    });
+
+    it('logs participant mismatch at warn level', () => {
+      logWxAppOfferParticipantMismatch({
+        interactionId: 'task-1',
+        usersubPublished: true,
+        hasDeviceCallId: false,
+        hasDeviceId: false,
+        participantDeviceType: 'wxApp',
+        acceptVisible: true,
+        acceptEnabled: false,
+        acceptReason: 'extension_non_wxApp_offer',
+      });
+
+      expect(LoggerProxy.warn).toHaveBeenCalledWith(
+        expect.stringContaining('participant fields mismatch'),
+        expect.objectContaining({
+          method: 'logWxAppOfferParticipantMismatch',
+          data: expect.objectContaining({
+            event: 'participant_fields_mismatch',
+            usersubPublished: true,
+            hasDeviceCallId: false,
           }),
         })
       );
@@ -131,7 +167,7 @@ describe('wxAppDiagnosticLogging', () => {
       });
 
       expect(LoggerProxy.error).toHaveBeenCalledWith(
-        `${WXAPP_LOG_PREFIX} telephony accept failed`,
+        expect.stringContaining('telephony accept failed'),
         expect.objectContaining({
           data: expect.objectContaining({
             trackingId: 'track-abc',