@webex/contact-center 3.12.0-next.121 → 3.12.0-next.123

package/.sdd/manifest.json

@@ -310,7 +310,7 @@
       "canonical_spec": "src/services/task/ai-docs/task-spec.md",
       "contracts": {
         "provides": [
-          "Task/Voice/WebRTC/Digital lifecycle APIs; TaskManager lifecycle correlation, narrowly scoped backend-authoritative ContactOwnerChanged recovery, and task-event publication, including routing owner-changing ContactUpdated through the existing task:hydrate event; task events/types; ordered action-specific consult/transfer destination controls; call-control and dialer operations including acceptPreviewContact, skipPreviewContact, and removePreviewContact"
+          "Task/Voice/WebRTC/Digital lifecycle APIs; TaskManager lifecycle correlation, narrowly scoped backend-authoritative ContactOwnerChanged recovery, and task-event publication, including routing owner-changing ContactUpdated through the existing task:hydrate event; TaskManager/Voice stamp wrapUpRequired on wrap-up ingress so task:wrapup and profile-gated auto wrap-up can start; task events/types; ordered action-specific consult/transfer destination controls; call-control and dialer operations including acceptPreviewContact, skipPreviewContact, and removePreviewContact"
         ],
         "requires": [
           "Contact/dialer AqmReqs; WebSocket managers; @webex/calling; MetricsManager; XState task-state module"

package/ai-docs/CONTRACTS.md

@@ -23,7 +23,7 @@
 | Contract ID | Owner module | Event / topic | Direction | Payload schema link | Delivery guarantees | Compatibility / deprecation | Defined at |
 |---|---|---|---|---|---|---|---|
 | `agent.events` | Agent | `agent:*` | publish to application | agent spec/types | realtime; backend ordering/correlation | additive constants | `src/services/agent/types.ts` |
-| `task.events` | Task | `task:*`, including existing `task:hydrate` | consume/map backend task lifecycle events, then publish to application/task | task spec `TASK-R-010` / types | `ContactOwnerChanged` and owner-changing `ContactUpdated` route through `CONTACT_OWNER_CHANGED`; a complete promoted-current-Agent owner change may narrowly recover a missing task; consumers receive one `task:hydrate` and no synthetic `task:incoming` | compatible semantic extension of an existing event; no new event constant; backend `interaction.owner` remains authoritative | `src/services/task/TaskManager.ts`, `src/services/task/Task.ts`, `src/services/task/types.ts` |
+| `task.events` | Task | `task:*`, including existing `task:hydrate` and `task:wrapup` | consume/map backend task lifecycle events, then publish to application/task | task spec `TASK-R-010` / `TASK-R-011` / types | `ContactOwnerChanged` and owner-changing `ContactUpdated` route through `CONTACT_OWNER_CHANGED`; a complete promoted-current-Agent owner change may narrowly recover a missing task; consumers receive one `task:hydrate` and no synthetic `task:incoming`. TaskManager stamps `wrapUpRequired` once at ingress (`AGENT_WRAPUP`, conference-end/leave/transfer when this agent should wrap; HTTP `exitConference` on Voice uses the same empty-pending self-exit fallback as leave — true unless this agent is a consulted non-owner — and pending-list precedence uses the correlated response only) so consumers may receive `task:wrapup` and `task.autoWrapup` on those events. `PARTICIPANT_LEAVE` into `WRAPPING_UP` does not transition-emit; the `WRAPPING_UP` entry still emits `task:wrapup`. A nonempty `agentsPendingWrapUp` wins over transfer initiator signals (`consultingAgentId` / `transferConferenceRequested`); a named other `participantId` is never self-leave; leave wrap-up is not stamped when the actor ignores `PARTICIPANT_LEAVE` (`CONNECTED`, `HOLD_INITIATING`, `CONF_INITIATING`); leave-self with empty/absent pending stamps true unless this agent is a consulted non-owner; remaining conference agents stay unstamped. Profile-gated auto wrap-up still requires `autoWrapup !== false`, interval, and a default reason | compatible semantic extension of existing events; no new event constant; backend `interaction.owner` remains authoritative | `src/services/task/TaskManager.ts`, `src/services/task/Task.ts`, `src/services/task/voice/Voice.ts`, `src/services/task/types.ts` |
 | `task.wxapp-mute.events` | Task | `task:wxapp-mute-state-updated` | publish to application/task | task spec/types | event-driven | additive | `src/services/task/types.ts`, `src/services/task/voice/Voice.ts` |
 | `cc.events` | Config/Core | backend CC_EVENTS | consume/map | config/core specs | remote WebSocket delivery; AQM correlation where configured | backend contract | `src/services/config/types.ts` |
 | `rtd.events` | Task | realtime transcription/suggestion | consume then publish per task | task spec | websocket best-effort according to remote service | additive payloads | `src/services/task/TaskManager.ts` |

package/dist/services/task/TaskManager.js

@@ -23,6 +23,8 @@ function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e
 const CC_EVENT_SET = new Set(Object.values(_types2.CC_EVENTS));
 const MAIN_INTERACTION_CORRELATED_EVENTS = new Set([_types2.CC_EVENTS.AGENT_CONSULT_ENDED, _types2.CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE]);
 const isCcEvent = value => CC_EVENT_SET.has(value);
+const WRAP_UP_STAMP_EVENTS = new Set([_types2.CC_EVENTS.AGENT_WRAPUP, _types2.CC_EVENTS.AGENT_CONSULT_CONFERENCE_ENDED, _types2.CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE, _types2.CC_EVENTS.AGENT_CONFERENCE_TRANSFERRED]);
+const PARTICIPANT_LEAVE_WRAP_STATES = new Set([_stateMachine.TaskState.HELD, _stateMachine.TaskState.RESUME_INITIATING, _stateMachine.TaskState.CONSULTING, _stateMachine.TaskState.CONSULT_INITIATING, _stateMachine.TaskState.CONFERENCING]);
 
 /** @internal */
 class TaskManager extends _events.default {
@@ -140,6 +142,138 @@ class TaskManager extends _events.default {
     this.webCallingService.off(_calling.LINE_EVENTS.INCOMING_CALL, this.handleIncomingWebCall);
   }
 
+  /**
+   * True when this agent left on the current payload.
+   * A named other participantId is never self-leave (even if the participants
+   * map is partial). Missing-map fallback is EP-DN only: participantId absent
+   * and self omitted now, with previous-task evidence when a prior map exists.
+   */
+  static didSelfLeaveConference(payload, agentId, task) {
+    if (!agentId) {
+      return false;
+    }
+    if (payload.participantId === agentId) {
+      return true;
+    }
+    if (payload.participantId && payload.participantId !== agentId) {
+      return false;
+    }
+    const participants = payload.interaction?.participants;
+    if (!participants || agentId in participants) {
+      return false;
+    }
+    const previousParticipants = task?.data?.interaction?.participants;
+    if (previousParticipants && !(agentId in previousParticipants)) {
+      return false;
+    }
+    return true;
+  }
+
+  /**
+   * Consulted non-owner: Voice exitConference / shouldWrapUpForThisAgent stays
+   * false unless an explicit wrap-up signal includes this agent.
+   */
+  static isConsultedNonOwner(payload, agentId, task) {
+    const isConsulted = payload.isConsulted ?? task?.data?.isConsulted;
+    if (isConsulted !== true) {
+      return false;
+    }
+    const owner = payload.interaction?.owner ?? task?.data?.interaction?.owner;
+    return Boolean(agentId && owner && owner !== agentId);
+  }
+  static hasNonemptyPendingWrapUp(payload) {
+    return Array.isArray(payload.agentsPendingWrapUp) && payload.agentsPendingWrapUp.length > 0;
+  }
+
+  /**
+   * Transfer initiator fallback: widgets set transferConferenceRequested on the
+   * actor; desktop success payloads may include consultingAgentId. Only used
+   * when agentsPendingWrapUp is empty or absent.
+   */
+  static isSelfConferenceTransferInitiator(payload, agentId, task) {
+    const snapshotContext = task?.stateMachineService?.getSnapshot?.()?.context;
+    if (snapshotContext?.transferConferenceRequested === true) {
+      return true;
+    }
+    return Boolean(agentId && payload.consultingAgentId === agentId);
+  }
+
+  /**
+   * Explicit wrap-up signals only (no owner / isConsulted fallback).
+   * Used for events that remaining conference agents also receive.
+   * nonempty agentsPendingWrapUp is authoritative, then wrapUpRequired / isWrapUp.
+   */
+  static wrapUpRequiredFromExplicitSignals(payload, agentId) {
+    const pending = payload.agentsPendingWrapUp;
+    if (Array.isArray(pending) && pending.length > 0) {
+      return Boolean(agentId && pending.includes(agentId));
+    }
+    if (payload.wrapUpRequired === true) {
+      return true;
+    }
+    if (!agentId) {
+      return false;
+    }
+    return payload.interaction?.participants?.[agentId]?.isWrapUp === true;
+  }
+
+  /**
+   * Stamp wrapUpRequired once at ingress (prepareEventContext) so updateTaskData
+   * and the mapper see the same flag. Remaining agents stay false.
+   */
+  static stampWrapUpRequiredForEvent(eventType, payload, agentId, task) {
+    if (!WRAP_UP_STAMP_EVENTS.has(eventType)) {
+      return payload;
+    }
+    if (eventType === _types2.CC_EVENTS.AGENT_WRAPUP) {
+      return {
+        ...payload,
+        wrapUpRequired: true
+      };
+    }
+    if (eventType === _types2.CC_EVENTS.AGENT_CONSULT_CONFERENCE_ENDED) {
+      return {
+        ...payload,
+        wrapUpRequired: TaskManager.wrapUpRequiredFromExplicitSignals(payload, agentId)
+      };
+    }
+    if (eventType === _types2.CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE) {
+      const actorState = task?.stateMachineService?.getSnapshot?.()?.value;
+      if (actorState && !PARTICIPANT_LEAVE_WRAP_STATES.has(actorState)) {
+        return payload;
+      }
+      const left = TaskManager.didSelfLeaveConference(payload, agentId, task);
+      if (!left) {
+        return {
+          ...payload,
+          wrapUpRequired: TaskManager.wrapUpRequiredFromExplicitSignals(payload, agentId)
+        };
+      }
+      if (TaskManager.hasNonemptyPendingWrapUp(payload)) {
+        return {
+          ...payload,
+          wrapUpRequired: Boolean(agentId && payload.agentsPendingWrapUp?.includes(agentId))
+        };
+      }
+      return {
+        ...payload,
+        wrapUpRequired: TaskManager.wrapUpRequiredFromExplicitSignals(payload, agentId) || !TaskManager.isConsultedNonOwner(payload, agentId, task)
+      };
+    }
+
+    // AGENT_CONFERENCE_TRANSFERRED — pending list wins; initiator only if empty/absent
+    if (TaskManager.hasNonemptyPendingWrapUp(payload)) {
+      return {
+        ...payload,
+        wrapUpRequired: TaskManager.wrapUpRequiredFromExplicitSignals(payload, agentId)
+      };
+    }
+    return {
+      ...payload,
+      wrapUpRequired: TaskManager.wrapUpRequiredFromExplicitSignals(payload, agentId) || TaskManager.isSelfConferenceTransferInitiator(payload, agentId, task)
+    };
+  }
+
   /**
    * Map WebSocket CC_EVENTS to state machine TaskEvent
    * @param ccEvent - The CC_EVENT type from WebSocket
@@ -594,6 +728,9 @@ class TaskManager extends _events.default {
     if (task && eventType === _types2.CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE) {
       adjustedPayload = TaskManager.preserveConfirmedOwner(task, adjustedPayload);
     }
+    if (WRAP_UP_STAMP_EVENTS.has(eventType)) {
+      adjustedPayload = TaskManager.stampWrapUpRequiredForEvent(eventType, adjustedPayload, this.agentId, task);
+    }
     const stateMachineEvent = TaskManager.mapEventToTaskStateMachineEvent(eventType, adjustedPayload, this.agentId, task, this.configFlags?.enableWxBetterTogether);
     _loggerProxy.default.info(`Handling task event ${eventType}`, {
       module: _constants.TASK_MANAGER_FILE,