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

package/src/services/task/voice/Voice.ts

@@ -50,12 +50,11 @@ import {
   WxAppVoiceLifecycle,
 } from './wxAppVoiceMethods';
 import {
-  deriveWxAppAcceptReason,
   logWxAppMercuryMuteSync,
-  logWxAppOfferDecision,
   callIdSuffix,
-  WxAppAcceptReason,
+  type WxAppAcceptReason,
 } from '../../wxAppDiagnosticLogging';
+import {WxAppOfferObservability, WxAppOfferObservabilityContext} from './wxAppOfferObservability';
 
 const hasNonemptyPendingWrapUp = (taskData?: TaskData): boolean =>
   Array.isArray(taskData?.agentsPendingWrapUp) && taskData.agentsPendingWrapUp.length > 0;
@@ -87,7 +86,9 @@ export default class Voice extends Task implements IVoice {
   private wxAppMuteSyncInFlight?: Promise<boolean | undefined>;
   private wxAppMuteToggleTail: Promise<void> = Promise.resolve();
   private wxAppDtmfTail: Promise<void> = Promise.resolve();
-  private lastLoggedWxAppAcceptReason?: WxAppAcceptReason;
+  /** Lazy — `super()` may call `updateUiControls` before field initializers run. */
+  private wxAppOfferObservability: WxAppOfferObservability | null = null;
+  private getUsersubPublished?: () => boolean;
 
   constructor(
     contact: ReturnType<typeof routingContact>,
@@ -117,6 +118,7 @@ export default class Voice extends Task implements IVoice {
 
     this.enableWxBetterTogether = resolvedOptions.enableWxBetterTogether;
     this.answerCallOnWebexService = callOptions?.answerCallOnWebexService;
+    this.getUsersubPublished = callOptions?.getUsersubPublished;
   }
 
   private getWxAppVoiceDependencies(): WxAppVoiceDependencies {
@@ -131,6 +133,7 @@ export default class Voice extends Task implements IVoice {
       setWxAppMuted: (muted: boolean) => {
         this.wxAppMuted = muted;
       },
+      getUsersubPublished: this.getUsersubPublished,
     };
   }
 
@@ -165,56 +168,54 @@ export default class Voice extends Task implements IVoice {
     this.updateUiControls(true);
   }
 
-  protected updateUiControls(forceEmit = false): void {
-    super.updateUiControls(forceEmit);
-    this.logWxAppOfferDecisionIfNeeded();
-  }
-
-  private logWxAppOfferDecisionIfNeeded(): void {
-    if (!this.enableWxBetterTogether) {
-      return;
+  private getOrCreateWxAppOfferObservability(): WxAppOfferObservability {
+    if (!this.wxAppOfferObservability) {
+      this.wxAppOfferObservability = new WxAppOfferObservability();
     }
 
-    const state = this.stateMachineService?.getSnapshot?.()?.value as TaskState | undefined;
-    if (state !== TaskState.OFFERED) {
-      return;
-    }
-
-    const accept = this.currentUiControls?.main?.accept;
-    if (!accept?.isVisible) {
-      return;
-    }
+    return this.wxAppOfferObservability;
+  }
 
-    const deps = this.getWxAppVoiceDependencies();
-    const isOutdial = this.data?.interaction?.outboundType === 'OUTDIAL';
-    const isWxAppInboundOffer = this.isWebexAppInboundCallingOffer();
-    const isWxAppOutdialOffer = this.isWebexAppCallingOffer() && isOutdial;
-    const deviceDetails = getCallingDeviceDetails(deps);
-    const acceptReason = deriveWxAppAcceptReason({
-      isWxAppInboundOffer,
-      isWxAppOutdialOffer,
-      isWebrtc: this.uiControlConfig.voiceVariant === VOICE_VARIANT.WEBRTC,
-      isOutdial,
-      wxAppAcceptInFlight: this.wxAppAcceptInFlight,
-      wxAppAnswerPending: this.wxAppAnswerPending,
-      enableWxBetterTogether: this.enableWxBetterTogether,
-      hasDeviceCallId: Boolean(deviceDetails?.deviceCallId),
-    });
+  protected updateUiControls(forceEmit = false): void {
+    super.updateUiControls(forceEmit);
+    this.getOrCreateWxAppOfferObservability().handleUiControlsUpdate(
+      this.getWxAppOfferObservabilityContext()
+    );
+  }
 
-    if (acceptReason === this.lastLoggedWxAppAcceptReason) {
-      return;
-    }
+  /**
+   * Re-run OFFERED wxApp diagnostics without emitting UI controls.
+   * Used after usersub publish so a pre-publish offer can schedule mismatch grace.
+   */
+  public refreshWxAppOfferObservability(): void {
+    this.getOrCreateWxAppOfferObservability().handleUiControlsUpdate(
+      this.getWxAppOfferObservabilityContext()
+    );
+  }
 
-    this.lastLoggedWxAppAcceptReason = acceptReason;
+  /**
+   * Cancel pending participant-mismatch grace timer. Observability only.
+   */
+  public disposeWxAppOfferObservability(): void {
+    this.wxAppOfferObservability?.dispose();
+  }
 
-    logWxAppOfferDecision({
-      interactionId: this.data.interactionId,
-      acceptVisible: accept.isVisible,
-      acceptEnabled: accept.isEnabled,
-      acceptReason,
-      wxAppParticipantDeviceType: deviceDetails?.deviceType,
-      hasDeviceCallId: Boolean(deviceDetails?.deviceCallId),
-    });
+  private getWxAppOfferObservabilityContext(): WxAppOfferObservabilityContext {
+    return {
+      getInteractionId: () => this.data.interactionId,
+      getTaskState: () => this.stateMachineService?.getSnapshot?.()?.value as TaskState | undefined,
+      getAcceptControl: () => this.currentUiControls?.main?.accept,
+      getVoiceVariant: () => this.uiControlConfig.voiceVariant ?? VOICE_VARIANT.PSTN,
+      isOutdial: () => this.data?.interaction?.outboundType === 'OUTDIAL',
+      isWxAppInboundOffer: () => this.isWebexAppInboundCallingOffer(),
+      isWxAppCallingOffer: () => this.isWebexAppCallingOffer(),
+      getWxAppAcceptInFlight: () => this.wxAppAcceptInFlight,
+      getWxAppAnswerPending: () => this.wxAppAnswerPending,
+      getEnableWxBetterTogether: () => this.enableWxBetterTogether,
+      getUsersubPublished: () => this.getUsersubPublished?.() ?? false,
+      getWxAppVoiceDependencies: () => this.getWxAppVoiceDependencies(),
+      getMetricsManager: () => this.metricsManager,
+    };
   }
 
   public applyWxAppMuteStateFromSync(incomingCallId: string, muted: boolean): void {
@@ -423,12 +424,26 @@ export default class Voice extends Task implements IVoice {
     return this.stateMachineService?.getSnapshot?.();
   }
 
+  private getWxAppAcceptReasonForMetrics(): WxAppAcceptReason {
+    if (this.wxAppAcceptInFlight) {
+      return 'wxApp_accept_in_flight';
+    }
+
+    if (this.wxAppAnswerPending) {
+      return 'wxApp_answer_pending';
+    }
+
+    return 'wxApp_offer_ready';
+  }
+
   /**
    * Accepts the task. Routes to wxApp telephony answer when `enableWxBetterTogether` and wxApp offer.
    */
   public async accept(): Promise<TaskResponse> {
     if (this.enableWxBetterTogether && this.isWebexAppCallingOffer()) {
-      await runWxAppAccept(this.getWxAppVoiceDependencies(), this.createWxAppLifecycle());
+      await runWxAppAccept(this.getWxAppVoiceDependencies(), this.createWxAppLifecycle(), {
+        acceptReason: this.getWxAppAcceptReasonForMetrics(),
+      });
 
       return Promise.resolve();
     }
@@ -441,7 +456,9 @@ export default class Voice extends Task implements IVoice {
    */
   public async decline(): Promise<TaskResponse> {
     if (this.enableWxBetterTogether && this.isWebexAppInboundCallingOffer()) {
-      await runWxAppReject(this.getWxAppVoiceDependencies(), this.createWxAppLifecycle());
+      await runWxAppReject(this.getWxAppVoiceDependencies(), this.createWxAppLifecycle(), {
+        acceptReason: this.getWxAppAcceptReasonForMetrics(),
+      });
 
       return Promise.resolve();
     }
@@ -464,9 +481,14 @@ export default class Voice extends Task implements IVoice {
         METRIC_EVENT_NAMES.TASK_DECLINE_FAILED,
       ]);
 
+      const declineAcceptReason = this.wxAppAnswerPending
+        ? 'wxApp_answer_pending'
+        : 'wxApp_offer_ready';
       this.setWxAppAnswerPending(false);
-      const response = await runWxAppOutdialDecline(this.getWxAppVoiceDependencies(), () =>
-        this.contact.cancelTask({interactionId})
+      const response = await runWxAppOutdialDecline(
+        this.getWxAppVoiceDependencies(),
+        () => this.contact.cancelTask({interactionId}),
+        {acceptReason: declineAcceptReason}
       );
 
       this.metricsManager.trackEvent(

package/src/services/task/voice/wxAppOfferObservability.ts

@@ -0,0 +1,204 @@
+import MetricsManager from '../../../metrics/MetricsManager';
+import {METRIC_EVENT_NAMES} from '../../../metrics/constants';
+import {
+  deriveWxAppAcceptReason,
+  logWxAppOfferDecision,
+  logWxAppOfferParticipantMismatch,
+  WxAppAcceptReason,
+} from '../../wxAppDiagnosticLogging';
+import {TaskState} from '../state-machine';
+import {VoiceVariant, VOICE_VARIANT} from '../types';
+import {
+  getCallingDeviceDetails,
+  getWxAppParticipantDiagnostics,
+  WxAppVoiceDependencies,
+} from './wxAppVoiceMethods';
+
+/** Defer mismatch WARN/metric so transient WS ordering gaps (~200–300 ms) do not false-alarm. */
+export const WXAPP_PARTICIPANT_MISMATCH_GRACE_MS = 500;
+
+export type WxAppOfferObservabilityContext = {
+  getInteractionId: () => string;
+  getTaskState: () => TaskState | undefined;
+  getAcceptControl: () => {isVisible: boolean; isEnabled: boolean} | undefined;
+  getVoiceVariant: () => VoiceVariant;
+  isOutdial: () => boolean;
+  isWxAppInboundOffer: () => boolean;
+  isWxAppCallingOffer: () => boolean;
+  getWxAppAcceptInFlight: () => boolean;
+  getWxAppAnswerPending: () => boolean;
+  getEnableWxBetterTogether: () => boolean;
+  getUsersubPublished: () => boolean;
+  getWxAppVoiceDependencies: () => WxAppVoiceDependencies;
+  getMetricsManager: () => MetricsManager;
+};
+
+/**
+ * OFFERED-state wxApp offer diagnostics: acceptReason logging and deferred participant mismatch.
+ * Invoked from Voice.updateUiControls — observability only.
+ */
+export class WxAppOfferObservability {
+  private lastLoggedWxAppAcceptReason?: WxAppAcceptReason;
+  private lastLoggedWxAppParticipantMismatch = false;
+  private wxAppParticipantMismatchGraceTimer?: ReturnType<typeof setTimeout>;
+  private disposed = false;
+
+  public handleUiControlsUpdate(ctx: WxAppOfferObservabilityContext): void {
+    if (this.disposed) {
+      return;
+    }
+
+    if (!ctx.getEnableWxBetterTogether()) {
+      this.cancelGraceTimer();
+
+      return;
+    }
+
+    const state = ctx.getTaskState();
+    if (state !== TaskState.OFFERED) {
+      this.cancelGraceTimer();
+
+      return;
+    }
+
+    const accept = ctx.getAcceptControl();
+    if (!accept?.isVisible) {
+      return;
+    }
+
+    const deps = ctx.getWxAppVoiceDependencies();
+    const isOutdial = ctx.isOutdial();
+    const isWxAppInboundOffer = ctx.isWxAppInboundOffer();
+    const isWxAppOutdialOffer = ctx.isWxAppCallingOffer() && isOutdial;
+    const deviceDetails = getCallingDeviceDetails(deps);
+    const participantDiagnostics = getWxAppParticipantDiagnostics(deps);
+    const usersubPublished = ctx.getUsersubPublished();
+    const acceptReason = deriveWxAppAcceptReason({
+      isWxAppInboundOffer,
+      isWxAppOutdialOffer,
+      isWebrtc: ctx.getVoiceVariant() === VOICE_VARIANT.WEBRTC,
+      isOutdial,
+      wxAppAcceptInFlight: ctx.getWxAppAcceptInFlight(),
+      wxAppAnswerPending: ctx.getWxAppAnswerPending(),
+      enableWxBetterTogether: ctx.getEnableWxBetterTogether(),
+      hasDeviceCallId: participantDiagnostics.hasDeviceCallId,
+    });
+
+    if (acceptReason !== this.lastLoggedWxAppAcceptReason) {
+      this.lastLoggedWxAppAcceptReason = acceptReason;
+
+      logWxAppOfferDecision({
+        interactionId: ctx.getInteractionId(),
+        acceptVisible: accept.isVisible,
+        acceptEnabled: accept.isEnabled,
+        acceptReason,
+        wxAppParticipantDeviceType:
+          deviceDetails?.deviceType ?? participantDiagnostics.participantDeviceType,
+        hasDeviceCallId: participantDiagnostics.hasDeviceCallId,
+        hasDeviceId: participantDiagnostics.hasDeviceId,
+        usersubPublished,
+      });
+    }
+
+    if (participantDiagnostics.hasValidWxAppParticipant || !usersubPublished) {
+      this.cancelGraceTimer();
+    } else if (!ctx.isOutdial() && !this.lastLoggedWxAppParticipantMismatch) {
+      this.scheduleGraceTimer(ctx);
+    }
+  }
+
+  public dispose(): void {
+    this.disposed = true;
+    this.cancelGraceTimer();
+  }
+
+  private cancelGraceTimer(): void {
+    if (this.wxAppParticipantMismatchGraceTimer !== undefined) {
+      clearTimeout(this.wxAppParticipantMismatchGraceTimer);
+      this.wxAppParticipantMismatchGraceTimer = undefined;
+    }
+  }
+
+  private scheduleGraceTimer(ctx: WxAppOfferObservabilityContext): void {
+    if (
+      this.disposed ||
+      this.lastLoggedWxAppParticipantMismatch ||
+      this.wxAppParticipantMismatchGraceTimer !== undefined
+    ) {
+      return;
+    }
+
+    this.wxAppParticipantMismatchGraceTimer = setTimeout(() => {
+      this.wxAppParticipantMismatchGraceTimer = undefined;
+      this.emitParticipantMismatchIfStillNeeded(ctx);
+    }, WXAPP_PARTICIPANT_MISMATCH_GRACE_MS);
+  }
+
+  private emitParticipantMismatchIfStillNeeded(ctx: WxAppOfferObservabilityContext): void {
+    if (
+      this.disposed ||
+      !ctx.getEnableWxBetterTogether() ||
+      this.lastLoggedWxAppParticipantMismatch
+    ) {
+      return;
+    }
+
+    if (ctx.isOutdial()) {
+      return;
+    }
+
+    if (ctx.getTaskState() !== TaskState.OFFERED) {
+      return;
+    }
+
+    const accept = ctx.getAcceptControl();
+    if (!accept?.isVisible) {
+      return;
+    }
+
+    const deps = ctx.getWxAppVoiceDependencies();
+    const participantDiagnostics = getWxAppParticipantDiagnostics(deps);
+    const usersubPublished = ctx.getUsersubPublished();
+
+    if (!usersubPublished || participantDiagnostics.hasValidWxAppParticipant) {
+      return;
+    }
+
+    const isOutdial = ctx.isOutdial();
+    const acceptReason = deriveWxAppAcceptReason({
+      isWxAppInboundOffer: ctx.isWxAppInboundOffer(),
+      isWxAppOutdialOffer: ctx.isWxAppCallingOffer() && isOutdial,
+      isWebrtc: ctx.getVoiceVariant() === VOICE_VARIANT.WEBRTC,
+      isOutdial,
+      wxAppAcceptInFlight: ctx.getWxAppAcceptInFlight(),
+      wxAppAnswerPending: ctx.getWxAppAnswerPending(),
+      enableWxBetterTogether: ctx.getEnableWxBetterTogether(),
+      hasDeviceCallId: participantDiagnostics.hasDeviceCallId,
+    });
+
+    this.lastLoggedWxAppParticipantMismatch = true;
+
+    logWxAppOfferParticipantMismatch({
+      interactionId: ctx.getInteractionId(),
+      usersubPublished,
+      hasDeviceCallId: participantDiagnostics.hasDeviceCallId,
+      hasDeviceId: participantDiagnostics.hasDeviceId,
+      participantDeviceType: participantDiagnostics.participantDeviceType,
+      acceptVisible: accept.isVisible,
+      acceptEnabled: accept.isEnabled,
+      acceptReason,
+    });
+
+    ctx.getMetricsManager().trackEvent(
+      METRIC_EVENT_NAMES.WXAPP_OFFER_PARTICIPANT_FIELDS_MISSING,
+      {
+        taskId: ctx.getInteractionId(),
+        usersubPublished,
+        hasDeviceCallId: participantDiagnostics.hasDeviceCallId,
+        hasDeviceId: participantDiagnostics.hasDeviceId,
+        acceptReason,
+      },
+      ['operational', 'behavioral']
+    );
+  }
+}

package/src/services/task/voice/wxAppVoiceMethods.ts

@@ -17,6 +17,7 @@ import {
 import {
   logWxAppTelephonyAction,
   logWxAppValidationFailure,
+  type WxAppAcceptReason,
   type WxAppTelephonyAction,
 } from '../../wxAppDiagnosticLogging';
 
@@ -35,6 +36,15 @@ export type WxAppVoiceDependencies = {
   getTaskState: () => TaskState | undefined;
   getWxAppMuted: () => boolean;
   setWxAppMuted: (muted: boolean) => void;
+  /** Read-only observability: whether usersub answer-calls-on-wxcc is active this session. */
+  getUsersubPublished?: () => boolean;
+};
+
+export type WxAppParticipantDiagnostics = {
+  participantDeviceType?: string;
+  hasDeviceCallId: boolean;
+  hasDeviceId: boolean;
+  hasValidWxAppParticipant: boolean;
 };
 
 /** @deprecated Use {@link WxAppVoiceDependencies} */
@@ -76,6 +86,34 @@ function getWxAppAgentParticipant(deps: WxAppVoiceDependencies): unknown {
   );
 }
 
+export function getWxAppParticipantDiagnostics(
+  deps: WxAppVoiceDependencies
+): WxAppParticipantDiagnostics {
+  const participant = getWxAppAgentParticipant(deps) as WxAppParticipant | undefined;
+  const hasDeviceCallId =
+    typeof participant?.deviceCallId === 'string' && participant.deviceCallId.trim() !== '';
+  const hasDeviceId =
+    typeof participant?.deviceId === 'string' && participant.deviceId.trim() !== '';
+
+  return {
+    participantDeviceType: participant?.deviceType,
+    hasDeviceCallId,
+    hasDeviceId,
+    hasValidWxAppParticipant: isWxAppParticipant(participant),
+  };
+}
+
+function getWxAppTelephonyMetricContext(
+  deps: WxAppVoiceDependencies
+): Record<string, boolean | string> {
+  const diagnostics = getWxAppParticipantDiagnostics(deps);
+
+  return {
+    hasDeviceCallId: diagnostics.hasDeviceCallId,
+    hasDeviceId: diagnostics.hasDeviceId,
+  };
+}
+
 export function getCallingDeviceDetails(
   deps: WxAppVoiceDependencies
 ): WebexCallingDeviceDetails | undefined {
@@ -169,11 +207,12 @@ function logTelephonyFailure(
 function getWxAppTelephonyMetricFailurePayload(
   deps: WxAppVoiceDependencies,
   error: unknown
-): Record<string, string> {
+): Record<string, string | boolean> {
   const wxError = error as WxAppTelephonyError;
-  const payload: Record<string, string> = {
+  const payload: Record<string, string | boolean> = {
     taskId: getInteractionId(deps) ?? '',
     error: error instanceof Error ? error.toString() : String(error),
+    ...getWxAppTelephonyMetricContext(deps),
   };
 
   if (wxError.trackingId) {
@@ -198,7 +237,11 @@ function getWxAppOutdialDeclineFailurePayload(
   const aqmDetails = (error as AqmWrappedError).details;
 
   if (aqmDetails) {
-    return {...base, ...MetricsManager.getCommonTrackingFieldForAQMResponseFailed(aqmDetails)};
+    return {
+      ...base,
+      ...getWxAppTelephonyMetricContext(deps),
+      ...MetricsManager.getCommonTrackingFieldForAQMResponseFailed(aqmDetails),
+    };
   }
 
   return getWxAppTelephonyMetricFailurePayload(deps, error);
@@ -324,7 +367,7 @@ export async function transmitDtmfOnWebex(
     throw new Error('WxApp call ID is unavailable');
   }
 
-  LoggerProxy.info('transmitDtmf', {
+  LoggerProxy.log('transmitDtmf', {
     module: 'wxAppVoiceMethods',
     method: METHODS.TRANSMIT_DTMF,
     data: {
@@ -343,12 +386,18 @@ export async function transmitDtmfOnWebex(
   logWxAppTelephonyAction({action: 'dtmf', phase: 'success', interactionId});
 }
 
+export type WxAppAcceptRejectOptions = {
+  lineOwnerId?: string;
+  acceptReason?: WxAppAcceptReason;
+};
+
 export async function runWxAppAccept(
   deps: WxAppVoiceDependencies,
   lifecycle: WxAppVoiceLifecycle,
-  options?: {lineOwnerId?: string}
+  options?: WxAppAcceptRejectOptions
 ): Promise<void> {
   const taskId = getInteractionId(deps);
+  const acceptReason = options?.acceptReason ?? 'wxApp_offer_ready';
 
   deps.metricsManager.timeEvent([
     METRIC_EVENT_NAMES.WXAPP_TASK_ACCEPT_SUCCESS,
@@ -362,16 +411,17 @@ export async function runWxAppAccept(
     lifecycle.resetWxAppMuted();
     await lifecycle.syncWxAppMuteFromCallDetails();
 
-    deps.metricsManager.trackEvent(METRIC_EVENT_NAMES.WXAPP_TASK_ACCEPT_SUCCESS, {taskId}, [
-      'operational',
-      'behavioral',
-    ]);
+    deps.metricsManager.trackEvent(
+      METRIC_EVENT_NAMES.WXAPP_TASK_ACCEPT_SUCCESS,
+      {taskId, acceptReason, ...getWxAppTelephonyMetricContext(deps)},
+      ['operational', 'behavioral']
+    );
   } catch (error) {
     lifecycle.setWxAppAnswerPending(false);
     logTelephonyFailure('accept', deps, error);
     deps.metricsManager.trackEvent(
       METRIC_EVENT_NAMES.WXAPP_TASK_ACCEPT_FAILED,
-      getWxAppTelephonyMetricFailurePayload(deps, error),
+      {acceptReason, ...getWxAppTelephonyMetricFailurePayload(deps, error)},
       ['operational', 'behavioral']
     );
     lifecycle.mapWxAppVoiceError(error, METHODS.ACCEPT);
@@ -383,9 +433,10 @@ export async function runWxAppAccept(
 export async function runWxAppReject(
   deps: WxAppVoiceDependencies,
   lifecycle: WxAppVoiceLifecycle,
-  options?: {lineOwnerId?: string}
+  options?: WxAppAcceptRejectOptions
 ): Promise<void> {
   const taskId = getInteractionId(deps);
+  const acceptReason = options?.acceptReason ?? 'wxApp_offer_ready';
 
   deps.metricsManager.timeEvent([
     METRIC_EVENT_NAMES.WXAPP_TASK_DECLINE_SUCCESS,
@@ -395,26 +446,33 @@ export async function runWxAppReject(
   try {
     await rejectOnWebex(deps, options);
 
-    deps.metricsManager.trackEvent(METRIC_EVENT_NAMES.WXAPP_TASK_DECLINE_SUCCESS, {taskId}, [
-      'operational',
-      'behavioral',
-    ]);
+    deps.metricsManager.trackEvent(
+      METRIC_EVENT_NAMES.WXAPP_TASK_DECLINE_SUCCESS,
+      {taskId, acceptReason, ...getWxAppTelephonyMetricContext(deps)},
+      ['operational', 'behavioral']
+    );
   } catch (error) {
     logTelephonyFailure('decline', deps, error);
     deps.metricsManager.trackEvent(
       METRIC_EVENT_NAMES.WXAPP_TASK_DECLINE_FAILED,
-      getWxAppTelephonyMetricFailurePayload(deps, error),
+      {acceptReason, ...getWxAppTelephonyMetricFailurePayload(deps, error)},
       ['operational', 'behavioral']
     );
     lifecycle.mapWxAppVoiceError(error, METHODS.REJECT);
   }
 }
 
+export type WxAppOutdialDeclineOptions = {
+  acceptReason?: WxAppAcceptReason;
+};
+
 export async function runWxAppOutdialDecline<T>(
   deps: WxAppVoiceDependencies,
-  executeCancel: () => Promise<T>
+  executeCancel: () => Promise<T>,
+  options?: WxAppOutdialDeclineOptions
 ): Promise<T> {
   const taskId = getInteractionId(deps);
+  const acceptReason = options?.acceptReason ?? 'wxApp_offer_ready';
 
   deps.metricsManager.timeEvent([
     METRIC_EVENT_NAMES.WXAPP_TASK_DECLINE_SUCCESS,
@@ -424,17 +482,18 @@ export async function runWxAppOutdialDecline<T>(
   try {
     const result = await executeCancel();
 
-    deps.metricsManager.trackEvent(METRIC_EVENT_NAMES.WXAPP_TASK_DECLINE_SUCCESS, {taskId}, [
-      'operational',
-      'behavioral',
-    ]);
+    deps.metricsManager.trackEvent(
+      METRIC_EVENT_NAMES.WXAPP_TASK_DECLINE_SUCCESS,
+      {taskId, acceptReason, ...getWxAppTelephonyMetricContext(deps)},
+      ['operational', 'behavioral']
+    );
 
     return result;
   } catch (error) {
     logWxAppOutdialDeclineFailure(deps, error);
     deps.metricsManager.trackEvent(
       METRIC_EVENT_NAMES.WXAPP_TASK_DECLINE_FAILED,
-      getWxAppOutdialDeclineFailurePayload(deps, error),
+      {acceptReason, ...getWxAppOutdialDeclineFailurePayload(deps, error)},
       ['operational', 'behavioral']
     );
     throw error;
@@ -458,7 +517,7 @@ export async function runWxAppToggleMute(
 
     deps.metricsManager.trackEvent(
       METRIC_EVENT_NAMES.WXAPP_TASK_MUTE_SUCCESS,
-      {taskId, targetMuted: deps.getWxAppMuted()},
+      {taskId, targetMuted: deps.getWxAppMuted(), ...getWxAppTelephonyMetricContext(deps)},
       ['operational', 'behavioral']
     );
   } catch (error) {
@@ -489,7 +548,7 @@ export async function runWxAppTransmitDtmf(
 
     deps.metricsManager.trackEvent(
       METRIC_EVENT_NAMES.WXAPP_TASK_DTMF_SUCCESS,
-      {taskId, dtmfLength: options.dtmf.length},
+      {taskId, dtmfLength: options.dtmf.length, ...getWxAppTelephonyMetricContext(deps)},
       ['operational', 'behavioral']
     );
   } catch (error) {