@qualified-salesforce/web 0.0.1-oidc-bootstrap → 0.1.0

package/widget/multimodal_v2/stores/artifact_store.js

@@ -1,13 +1,33 @@
 import { __webpack_require__ } from "../../../js/runtime.js";
-import { signals_core_module_r, signals_core_module_d } from "../../../js/multimodal_v2.js";
+import { signals_core_module_d, signals_core_module_w, signals_core_module_E, signals_core_module_r } from "../../../js/multimodal_v2.js";
+import { getSentryClient } from "../../widget/sentry.js";
 import { BaseStore } from "./base_store.js";
 import "../../utils/native_globals.js";
-import { MaximizedState as types_MaximizedState } from "../types.js";
+import { MaximizedState as types_MaximizedState, StartCallTrigger as types_StartCallTrigger } from "../types.js";
 
 /* provided dependency */ var artifact_store_setTimeout = __webpack_require__(68034).pS;
+/* provided dependency */ var artifact_store_clearTimeout = __webpack_require__(68034).Kj;
+function _extends() {
+    _extends = Object.assign || function(target) {
+        for(var i = 1; i < arguments.length; i++){
+            var source = arguments[i];
+            for(var key in source){
+                if (Object.prototype.hasOwnProperty.call(source, key)) {
+                    target[key] = source[key];
+                }
+            }
+        }
+        return target;
+    };
+    return _extends.apply(this, arguments);
+}
+
 
 
 
+// Expiry closes the overlay rather than giving the deck back: handing it back
+// paints the self-guided viewer while Piper's share may still be seconds away.
+const DECK_PRESENTATION_START_TIMEOUT_MS = 30000;
 /**
  * Owns artifact orchestration: presenting slides / presentation videos / the
  * meeting booker in the maximized ARTIFACT overlay, navigating the host page
@@ -48,7 +68,17 @@ import { MaximizedState as types_MaximizedState } from "../types.js";
             this.markPending(message.id);
             try {
                 if (delayMs > 0) await new Promise((resolve)=>artifact_store_setTimeout(resolve, delayMs));
-                await this.presentArtifactMessage(message);
+                await this.presentArtifactMessage(message, {
+                    origin: "incoming"
+                });
+            } catch (error) {
+                var _getSentryClient;
+                (_getSentryClient = getSentryClient({
+                    project: "multimodal"
+                })) == null ? void 0 : _getSentryClient.captureException(error);
+                if (message.type === "calendar_event_offer") {
+                    this.rootStore.reportBookerLoadFailure(message, "chat");
+                }
             } finally{
                 // Safe to release the slot now: on the way through here the artifact id has
                 // been set, so the renderer is already withholding it for that reason
@@ -64,19 +94,20 @@ import { MaximizedState as types_MaximizedState } from "../types.js";
    * Unlike {@link queueArtifactMessage} this leaves the timeline alone, for the
    * visitor asking to (re)open an artifact from a card that is already on screen:
    * hiding it mid-load would blank the spot they just clicked.
-   */ this.presentArtifactMessage = async (message)=>{
+   */ this.presentArtifactMessage = async (message, param)=>{
+            let { origin = "revisit" } = param === void 0 ? {} : param;
             switch(message.type){
                 case "present_content":
                     await this.rootStore.slidesStore.load();
                     // Mirror the on-screen slide into the voice agent's perception loop
                     // (ScreenShareStore ships it via the update_perception channel action).
                     this.loadSlidePerception();
-                    this.showArtifact(message);
+                    this.showArtifact(message, origin);
                     break;
                 case "present_video":
                     if (this.rootStore.callInProgress.value) {
                         await this.rootStore.presentationsStore.load();
-                        if (!this.hiddenArtifactIds.has(message.id)) this.showArtifact(message);
+                        if (!this.hiddenArtifactIds.has(message.id)) this.showArtifact(message, origin);
                     }
                     break;
                 case "present_deck":
@@ -98,7 +129,7 @@ import { MaximizedState as types_MaximizedState } from "../types.js";
                             // (ScreenShareStore ships it via the update_perception channel action).
                             // Gated with the present so we only mirror a live, on-screen slide.
                             this.loadSlidePerception();
-                            this.showArtifact(message);
+                            this.showArtifact(message, origin);
                         }
                     }
                     break;
@@ -107,7 +138,7 @@ import { MaximizedState as types_MaximizedState } from "../types.js";
                     // element-conversation lightbox is a separate flow; see
                     // RootStore#elementConversationOffer.)
                     await this.rootStore.meetingStore.load();
-                    this.showArtifact(message);
+                    this.showArtifact(message, origin);
                     break;
                 case "navigate_content":
                     // The one kind that never reaches the overlay: it drives the host page
@@ -124,7 +155,108 @@ import { MaximizedState as types_MaximizedState } from "../types.js";
             // is the last share, whose `slides` may not include this slide, so the store
             // can't look the title up from it.
             store.prepareRevisit(message.id, slideIndex, pageTitle);
-            this.showArtifact(message);
+            this.showArtifact(message, "revisit");
+        }, // card. Like revisitDeckSlide this bypasses the call gate above — the visitor
+        // asked for it, so it is legal off-call — and goes straight to showArtifact so
+        // a deck they dismissed earlier can be reopened.
+        //
+        // Nothing is reported back: no channel action for the agent and no analytics
+        // event, so a visitor reading the deck on their own is invisible to Piper and
+        // does not count as a presentation. Known gap, not yet a product decision.
+        this.presentSelfGuidedDeck = async (message)=>{
+            const store = await this.rootStore.decksStore.load();
+            store.prepareSelfGuidedPlayback(message.id);
+            this.showArtifact(message, "revisit");
+        }, /**
+   * Puts the deck the visitor is handing over into its starting state: their
+   * slide held on screen, dimmed, with the viewer's controls dropped, while the
+   * call that will present it starts (CurrentDeck#starting).
+   *
+   * Called from RootStore#startCall, which is where both ways into a deck
+   * presentation meet — the deck's timeline card and the self-guided viewer's
+   * switch to voice both reach it through the call UI adapter — so neither has to
+   * know this exists. Nothing happens for any other trigger, `StartPresentation`
+   * included: a product demo starts from a card, not from a frame of video the
+   * visitor was already watching, so there is nothing of theirs to hold.
+   *
+   * Routed through `presentSelfGuidedDeck`'s door rather than
+   * `presentArtifactMessage`'s, and that is the point: the call does not exist
+   * yet, so this is an off-call view of a deck, which is exactly what the
+   * self-guided route is for. The guided route's `callInProgress` gate stays as
+   * it is — it guards Piper presenting, and she is not presenting yet.
+   *
+   * Awaited by its caller, so it is written to be safe to wait on: see
+   * `loadDecksForHandOff`. It resolves either way and never rejects.
+   */ this.startDeckPresentation = async (trigger)=>{
+            var _ref, _ref1;
+            if ((trigger == null ? void 0 : trigger.type) !== types_StartCallTrigger.StartDeck) return;
+            const store = await this.loadDecksForHandOff();
+            if (!store) return;
+            // The self-guided viewer is the only thing that puts a deck slide in front of
+            // the visitor off-call, so whether it is open is the whole of the question
+            // "which slide were they on". Open: the one it is showing, read from the
+            // viewer rather than from the trigger so this says what it means. Closed:
+            // they were looking at the deck's timeline card, whose preview is the deck's
+            // cover, so the cover is where the deck opens.
+            const viewer = this.selfGuidedDeckOnScreen(trigger.deckId);
+            const message = (_ref = viewer == null ? void 0 : viewer.message) != null ? _ref : this.latestDeckShare(trigger.deckId);
+            if (!message) return;
+            store.prepareStartingPresentation(message.id, (_ref1 = viewer == null ? void 0 : viewer.currentDeck.currentIndex) != null ? _ref1 : 0);
+            // Already the artifact in the switch-to-voice case, where the visitor is
+            // looking at this very share: the starting state is then a state change on
+            // what is on screen, with nothing to open and nothing to swap. Skipped rather
+            // than re-shown so it does not read as a revisit of itself, which is a
+            // lifecycle event (showArtifact) and not what happened.
+            if (this.current.messageId.peek() !== message.id) {
+                this.showArtifact(message, "revisit");
+            }
+            this.watchDeckPresentation();
+        }, /**
+   * The decks chunk on the only terms a call start can afford to wait on: a fetch
+   * that rejects, or that is still in flight when the hand-off it feeds would have
+   * expired anyway, gives up and lets the call start without the overlay.
+   *
+   * The visitor asked for a call, and the held slide is a courtesy on top of it.
+   * Bounded by the hand-off's own deadline rather than a second number, because
+   * that is the same wait: a chunk that has not landed by then has no hand-off
+   * left to set up.
+   */ this.loadDecksForHandOff = async ()=>{
+            let abandon;
+            const bound = new Promise((resolve)=>{
+                abandon = artifact_store_setTimeout(()=>resolve(null), DECK_PRESENTATION_START_TIMEOUT_MS);
+            });
+            try {
+                return await Promise.race([
+                    this.rootStore.decksStore.load().catch(()=>null),
+                    bound
+                ]);
+            } finally{
+                artifact_store_clearTimeout(abandon);
+            }
+        }, /**
+   * Gives the deck back to the visitor: the viewer returns, at the slide they
+   * handed over, and its controls come back with it.
+   *
+   * The whole of giving up, because nothing was taken apart to get here — the
+   * starting state is a flag over a viewer that stayed exactly where it was. From
+   * the timeline card that leaves them in the deck they asked to be shown, able
+   * to read it themselves, which is the same place the card's own "view deck"
+   * affordance would have put them and a better answer than closing the overlay
+   * on a deck they just asked for. Both entry points therefore land in one state,
+   * and the messenger behind it holds the "voice and video are temporarily
+   * unavailable" notice that explains why nobody is presenting
+   * (AiConversationStore#failoverToText).
+   *
+   * Idempotent, and the only way out that has to be: the other two — Piper's
+   * share arriving, the overlay closing — clear the visitor's playback state
+   * wholesale and take this with it (DecksStore#clearSelfGuided).
+   *
+   * For a start that failed, and only that: the wait running out closes the
+   * overlay instead, and deliberately does not come through here.
+   */ this.endDeckPresentation = ()=>{
+            var _this_rootStore_decksStore_value;
+            this.stopWatchingDeckPresentation();
+            (_this_rootStore_decksStore_value = this.rootStore.decksStore.value) == null ? void 0 : _this_rootStore_decksStore_value.cancelStartingPresentation();
         }, /**
    * Tears down the overlay for whatever artifact is in it. Deliberately says
    * nothing about the meeting booker: clearing the artifact message is the whole
@@ -132,37 +264,89 @@ import { MaximizedState as types_MaximizedState } from "../types.js";
    * has. Meeting-aware teardown — which also has the element conversation to let
    * go of — belongs to `closeMeetingBooker` and `clearMeetingArtifact`.
    */ this.clearArtifact = ()=>{
+            var _this_rootStore_decksStore_value, _this_rootStore_decksStore_value1;
             const artifactMessage = this.current.message.value;
             const closedArtifact = this.rootStore.maximizedState.value === types_MaximizedState.ARTIFACT && ((artifactMessage == null ? void 0 : artifactMessage.type) === "present_video" || (artifactMessage == null ? void 0 : artifactMessage.type) === "present_deck") ? artifactMessage : null;
+            // A deck the visitor was driving themselves is theirs to close. Piper isn't
+            // presenting it, so the agent must not hear about it below and apologise for
+            // a presentation it never gave.
+            const closedSelfGuided = (closedArtifact == null ? void 0 : closedArtifact.type) === "present_deck" && Boolean((_this_rootStore_decksStore_value = this.rootStore.decksStore.value) == null ? void 0 : _this_rootStore_decksStore_value.isSelfGuided(closedArtifact.id));
+            // A single slide the visitor pulled back up from the transcript is a review of
+            // something already shown, so it reports no progress: the deck message it
+            // targets is the latest share, which may already hold the whole run's
+            // progress, and a review of slide 2 would overwrite that with slides 0-2.
+            const closedRevisit = (closedArtifact == null ? void 0 : closedArtifact.type) === "present_deck" && Boolean((_this_rootStore_decksStore_value1 = this.rootStore.decksStore.value) == null ? void 0 : _this_rootStore_decksStore_value1.isRevisiting(closedArtifact.id));
+            // How far the presentation got, read before the teardown below: that clears
+            // the overlay's message id, and `currentDeck` is derived from it.
+            const closedDeckProgress = (closedArtifact == null ? void 0 : closedArtifact.type) === "present_deck" && !closedSelfGuided && !closedRevisit ? this.deckProgress(closedArtifact) : null;
             if (closedArtifact) {
                 this.hiddenArtifactIds.add(closedArtifact.id);
             }
+            const presentationMessage = (artifactMessage == null ? void 0 : artifactMessage.type) === "present_content" || (artifactMessage == null ? void 0 : artifactMessage.type) === "present_video" || (artifactMessage == null ? void 0 : artifactMessage.type) === "present_deck" ? artifactMessage : null;
+            if (presentationMessage) {
+                this.rootStore.presentationTelemetryStore.onVisitorDismiss(presentationMessage.id);
+            }
             this.rootStore.clearMaximizedState({
                 when: types_MaximizedState.ARTIFACT
             });
             // Closing the presentation overlay mid-call: let the agent know so it stops
             // narrating and acknowledges that the visitor dismissed the presentation.
-            if (closedArtifact && this.rootStore.callInProgress.value) {
-                this.channel.perform("notify_artifact_closed", {
+            if (closedArtifact && !closedSelfGuided && this.rootStore.callInProgress.value) {
+                this.channel.perform("notify_artifact_closed", _extends({
                     artifact_type: closedArtifact.type === "present_video" ? "presentation" : "deck",
                     artifact_message_id: closedArtifact.id
-                });
+                }, closedDeckProgress != null ? closedDeckProgress : {}));
             }
-        }, /** Silently hides the live deck/demo targeted by Piper's hide event. */ this.hideArtifact = (artifactMessageId)=>{
+        }, /**
+   * How far a guided deck had got when the visitor closed it: the slide on screen
+   * and the sequence it belongs to, reported exactly as a barge-in reports them
+   * (DecksStore#notifyInterruption). The server splits the sequence at the
+   * on-screen slide to record what was really presented, and clears the deck's
+   * `awaiting_narration` in the same write.
+   *
+   * Deliberately without the barge-in guards (auto-advancing, more than one
+   * slide, not already on the last one). Those exist because resuming is all a
+   * barge-in reports for, and there is nothing to resume in those cases. A close
+   * also has to clear `awaiting_narration`, and a deck left carrying it absorbs
+   * the next assistant transcript into itself, marking its whole payload
+   * presented (Internal::PyperxController#absorb_deck_narration!) — which is
+   * exactly what a single-slide deck or a close on the last slide would hit. So
+   * every close reports.
+   */ this.deckProgress = (message)=>{
+            var _message_slides;
             var _this_rootStore_decksStore_value;
+            const current = (_this_rootStore_decksStore_value = this.rootStore.decksStore.value) == null ? void 0 : _this_rootStore_decksStore_value.currentDeck.value;
+            if (!current) return null;
+            const sequence = ((_message_slides = message.slides) != null ? _message_slides : []).map((slide)=>slide.slideIndex);
+            return {
+                deck_id: message.deckId,
+                current_slide_index: current.currentIndex,
+                // A legacy share carries no `slides`, but it still put one slide on screen.
+                // Standing in for the sequence keeps it non-empty, which is what the server
+                // needs before it will record anything at all.
+                sequence_slide_indexes: sequence.length > 0 ? sequence : [
+                    current.currentIndex
+                ]
+            };
+        }, /** Silently hides the live deck/demo targeted by Piper's hide event. */ this.hideArtifact = (artifactMessageId)=>{
+            var _this_rootStore_decksStore_value, _this_rootStore_decksStore_value1;
             // Record the hide before checking the current overlay. The matching artifact
             // may still be waiting on a lazy store; when that wait resolves,
             // presentArtifactMessage checks this set and does not open stale content.
             this.hiddenArtifactIds.add(artifactMessageId);
             const artifactMessage = this.current.message.value;
+            // The visitor's own view of the deck — a single revisited slide, or the deck
+            // they are stepping through — belongs to them, not to Piper's presentation.
+            const isMatchingRevisit = (artifactMessage == null ? void 0 : artifactMessage.id) === artifactMessageId && artifactMessage.type === "present_deck" && Boolean(((_this_rootStore_decksStore_value = this.rootStore.decksStore.value) == null ? void 0 : _this_rootStore_decksStore_value.isRevisiting(artifactMessageId)) || ((_this_rootStore_decksStore_value1 = this.rootStore.decksStore.value) == null ? void 0 : _this_rootStore_decksStore_value1.isSelfGuided(artifactMessageId)));
+            if (!isMatchingRevisit) {
+                this.rootStore.presentationTelemetryStore.onAgentHide(artifactMessageId);
+            }
             if (this.rootStore.maximizedState.value !== types_MaximizedState.ARTIFACT) return;
             if ((artifactMessage == null ? void 0 : artifactMessage.id) !== artifactMessageId) return;
             if (artifactMessage.type !== "present_video" && artifactMessage.type !== "present_deck") return;
             // A visitor may reopen an old deck slide from the timeline after Piper has
             // finished. A late/replayed completion event must not close that review.
-            if (artifactMessage.type === "present_deck" && ((_this_rootStore_decksStore_value = this.rootStore.decksStore.value) == null ? void 0 : _this_rootStore_decksStore_value.isRevisiting(artifactMessageId))) {
-                return;
-            }
+            if (isMatchingRevisit) return;
             // Do not call clearArtifact: that path represents a visitor dismissal and
             // notifies Piper when a video is closed mid-presentation.
             this.rootStore.clearMaximizedState({
@@ -184,20 +368,161 @@ import { MaximizedState as types_MaximizedState } from "../types.js";
             const pending = new Set(this.pending.peek());
             if (!pending.delete(messageId)) return;
             this.pending.value = pending;
-        }, this.showArtifact = (message)=>{
+        }, this.deckPresentationWatch = null, this.deckPresentationTimer = null, /** Starts the wait's clock once per hand-off. Not a signal: nothing renders it. */ this.deckPresentationDeadlineArmed = false, /**
+   * Whether the deck's starting state is still waiting on the call, as opposed to
+   * on the presentation — the boundary between its two messages
+   * (components/decks/index.tsx reads this for its text).
+   *
+   * `isVideoLoading` because that is the signal the call UI's own connecting state
+   * is drawn from: useMultimodal's `isConnecting` is exactly this, and it is what
+   * decides whether "Connecting you to {name}" — the same string this overlay
+   * borrows — is on screen in the multimodal component. Bound to the same signal
+   * rather than to one that merely correlates with it, so the two surfaces cannot
+   * disagree about whether the call is still coming up. They did: `isAudioConnected`
+   * (coffee's `is_audio_ready`, which is a VAD signal) lags the moment the call UI
+   * stops saying connecting, and Piper could be heard talking over an overlay that
+   * still read "connecting".
+   *
+   * The second term is the window before there is a call at all, which
+   * `isVideoLoading` does not cover on its own: RootStore#startCall raises it in
+   * the same tick it opens this overlay, so today no frame ever renders with a
+   * call-less deck — but stated rather than relied on, because "no call yet" being
+   * part of connecting is a property of this state and not of the order of two
+   * statements in another file. It cannot disagree with the call UI either: with no
+   * call there is nothing there to call ready. Once `isVideoLoading` has gone false
+   * the call object exists by construction (CallStore raises it on coffee's own
+   * status), so this term never fires again afterwards.
+   */ this.deckPresentationConnecting = signals_core_module_w(()=>{
+            const { state } = this.rootStore.getCallUiAdapter();
+            return state.isVideoLoading.value || !state.isInCall.value;
+        }), /**
+   * The starting state's life is the call start it is waiting on, so that is what
+   * is watched rather than any one failure. `isVideoLoading` is the widget's
+   * existing "a call is starting" flag (RootStore, raised by
+   * AiConversationStore#startConversation) and `isInCall` is the call itself, so
+   * neither being true means the attempt is over and no call came out of it —
+   * which is every way a start can fail at once, the room-creation failover behind
+   * `failoverToText` included, rather than a list of them that the next failure
+   * path would not be on.
+   *
+   * The same watch starts the wait's clock, off the label's own condition
+   * (`deckPresentationConnecting`): the label follows it live, the clock once.
+   */ this.watchDeckPresentation = ()=>{
+            this.stopWatchingDeckPresentation();
+            // Neither flag is up yet on this first run: startCall opens the overlay before
+            // it reaches the store that starts connecting. So the attempt has to be seen
+            // to begin before its absence can mean it ended.
+            let startSeen = false;
+            this.deckPresentationWatch = signals_core_module_E(()=>{
+                var _this_rootStore_decksStore_value_currentDeck_value, _this_rootStore_decksStore_value;
+                // Ended by something that had no reason to tell this watch: Piper's own
+                // share replacing the message, or the overlay closing. Both clear the
+                // visitor's playback state and the flag with it
+                // (DecksStore#clearSelfGuided), leaving nothing to wait for.
+                if (!((_this_rootStore_decksStore_value = this.rootStore.decksStore.value) == null ? void 0 : (_this_rootStore_decksStore_value_currentDeck_value = _this_rootStore_decksStore_value.currentDeck.value) == null ? void 0 : _this_rootStore_decksStore_value_currentDeck_value.starting)) {
+                    void Promise.resolve().then(this.stopWatchingDeckPresentation);
+                    return;
+                }
+                // Read through the adapter, which is what already derives these for the call
+                // UI, rather than re-deriving them from the call store. Fetched inside the
+                // effect because the adapter is built per call and swaps under debug mode;
+                // its signals are the stores' own either way.
+                const { state } = this.rootStore.getCallUiAdapter();
+                const starting = state.isVideoLoading.value;
+                const inCall = state.isInCall.value;
+                // Once, on the first time the call reads as connected: a reconnect renews
+                // neither the promise of a presentation nor the deadline on it.
+                if (!this.deckPresentationConnecting.value && !this.deckPresentationDeadlineArmed) {
+                    this.deckPresentationDeadlineArmed = true;
+                    this.armDeckPresentationTimeout();
+                }
+                if (starting || inCall) {
+                    startSeen = true;
+                    return;
+                }
+                if (!startSeen) return;
+                // Off the effect deliberately: ending the starting state disposes this very
+                // effect, and disposing an effect from inside its own callback is not
+                // something @preact/signals promises to survive.
+                void Promise.resolve().then(this.endDeckPresentation);
+            });
+        }, this.armDeckPresentationTimeout = ()=>{
+            if (this.deckPresentationTimer !== null) artifact_store_clearTimeout(this.deckPresentationTimer);
+            this.deckPresentationTimer = artifact_store_setTimeout(()=>{
+                var _decksStore_currentDeck_peek;
+                this.deckPresentationTimer = null;
+                // The watch clears this timer a microtask after the state it reads changes,
+                // so a fire that beat the clear must not close an arrived presentation.
+                const decksStore = this.rootStore.decksStore.peek();
+                if (!(decksStore == null ? void 0 : (_decksStore_currentDeck_peek = decksStore.currentDeck.peek()) == null ? void 0 : _decksStore_currentDeck_peek.starting)) return;
+                this.stopWatchingDeckPresentation();
+                // The message goes unconditionally, not as the close's side effect: it is
+                // what clears the flag, through the deck store's own subscription.
+                signals_core_module_r(()=>{
+                    this.rootStore.clearMaximizedState({
+                        when: types_MaximizedState.ARTIFACT
+                    });
+                    this.rootStore.setUIState({
+                        artifactMessageId: null
+                    });
+                });
+            }, DECK_PRESENTATION_START_TIMEOUT_MS);
+        }, /**
+   * Stands the watch and its clock down and forgets the phase, without touching
+   * the deck. Separate from `endDeckPresentation` because the starting state can
+   * end without this store deciding it should — see the effect above.
+   */ this.stopWatchingDeckPresentation = ()=>{
+            this.deckPresentationWatch == null ? void 0 : this.deckPresentationWatch.call(this);
+            this.deckPresentationWatch = null;
+            // Every route out of the starting state passes through here, so the next
+            // hand-off cannot inherit a deadline the last one already spent.
+            this.deckPresentationDeadlineArmed = false;
+            if (this.deckPresentationTimer !== null) {
+                artifact_store_clearTimeout(this.deckPresentationTimer);
+                this.deckPresentationTimer = null;
+            }
+        }, /** The latest share of a deck that has a card of its own, as its card picks one. */ this.latestDeckShare = (deckId)=>{
+            const messages = this.rootStore.messages.peek();
+            for(let i = messages.length - 1; i >= 0; i--){
+                const message = messages[i];
+                if ((message == null ? void 0 : message.type) === "present_deck" && message.deckId === deckId && !message.navigationOnly) {
+                    return message;
+                }
+            }
+            return null;
+        }, /** The deck the visitor is stepping through themselves, if that is what is on screen. */ this.selfGuidedDeckOnScreen = (deckId)=>{
+            if (this.rootStore.maximizedState.peek() !== types_MaximizedState.ARTIFACT) return null;
+            const message = this.current.message.peek();
+            if ((message == null ? void 0 : message.type) !== "present_deck" || message.deckId !== deckId) return null;
+            const decksStore = this.rootStore.decksStore.value;
+            if (!(decksStore == null ? void 0 : decksStore.isSelfGuided(message.id))) return null;
+            const currentDeck = decksStore.currentDeck.peek();
+            return currentDeck ? {
+                message,
+                currentDeck
+            } : null;
+        }, this.showArtifact = (message, origin)=>{
+            const replacedMessage = this.current.message.peek();
+            const incomingPresentation = origin === "incoming" && (message.type === "present_content" || message.type === "present_video" || message.type === "present_deck");
+            if (((replacedMessage == null ? void 0 : replacedMessage.id) !== message.id || origin === "revisit") && !incomingPresentation && ((replacedMessage == null ? void 0 : replacedMessage.type) === "present_content" || (replacedMessage == null ? void 0 : replacedMessage.type) === "present_video" || (replacedMessage == null ? void 0 : replacedMessage.type) === "present_deck")) {
+                this.rootStore.presentationTelemetryStore.onArtifactHidden(replacedMessage.id, "replaced");
+            }
             if (this.current.messageId.value === message.id) {
                 this.rootStore.setMaximizedState(types_MaximizedState.ARTIFACT);
-                return;
-            }
-            signals_core_module_r(()=>{
-                this.rootStore.setUIState({
-                    artifactMessageId: message.id
+            } else {
+                signals_core_module_r(()=>{
+                    this.rootStore.setUIState({
+                        artifactMessageId: message.id
+                    });
+                    this.rootStore.setMaximizedState(types_MaximizedState.ARTIFACT);
+                    if (this.rootStore.displayMode.minimized.value && !this.rootStore.conversationMode.video.value) {
+                        this.rootStore.setOpenedDisplayMode();
+                    }
                 });
-                this.rootStore.setMaximizedState(types_MaximizedState.ARTIFACT);
-                if (this.rootStore.displayMode.minimized.value && !this.rootStore.conversationMode.video.value) {
-                    this.rootStore.setOpenedDisplayMode();
-                }
-            });
+            }
+            if (origin === "incoming" && (message.type === "present_content" || message.type === "present_video" || message.type === "present_deck")) {
+                this.rootStore.presentationTelemetryStore.onLiveArtifactVisible(message);
+            }
         };
     }
 }

package/widget/multimodal_v2/stores/call_store.js

@@ -155,6 +155,14 @@ class CallStore {
             if (dailyWsProxyUrl) {
                 dailyConfig.proxyUrl = dailyWsProxyUrl;
             }
+            // QAI-5864 (deferred): this is where the future "voice" capability guard belongs — an
+            // `isCapabilityAllowed("voice")` check gating `createCallObject`/`join` is what stops
+            // daily-js from contacting its `c.daily.co` fallback origin. It is a no-op for today's
+            // text-only npm package: `setup()` never defines the call-machine URL there, so the
+            // `selfHosted && !localBundleUrl` throw above already fires before this line and no Daily
+            // connection is established. The guard (plus a "voice" entry in CAPABILITY_KEYS /
+            // CAPABILITY_CONFIG_ENABLERS with piperXAgentVoice/piperXAgentAvatar) lands with the voice
+            // build, per capabilities.ts.
             this.persistentCallObject = Ha.createCallObject({
                 dailyConfig
             });
@@ -260,6 +268,11 @@ class CallStore {
         this.isSilentRestart = signals_core_module_d(false);
         this.voiceGreetingStartTimestamp = null;
         this.isVisitorSpeaking = signals_core_module_d(false);
+        this.isBotSpeaking = signals_core_module_d(false);
+        // Monotonic Coffee marker emitted on the first audio byte of each distinct
+        // realtime response. Unlike isBotSpeaking, this advances even when a tool
+        // preamble and its continuation play without an audible silence gap.
+        this.voiceAnswerSequence = signals_core_module_d(null);
         this.audioAnalyser = signals_core_module_d(null);
         this.audioContext = null;
         this.currentAudioTrackId = null;
@@ -382,6 +395,10 @@ class CallStore {
                 status
             });
         };
+        this.endCall = async ()=>{
+            this.endPresentationTelemetry();
+            await this.aiConversationStore.endConversation();
+        };
         this.leaveCall = async ()=>{
             const call = this.dailyCall.value;
             if (!call) return;
@@ -446,6 +463,7 @@ class CallStore {
         this.handleCoffeeStateUpdate = (state)=>{
             this.logCoffeeTimingMetrics(state);
             signals_core_module_r(()=>{
+                var _state_voice_answer_seq;
                 var _this_perceivedTracker, _this_perceivedTracker1, _this_perceivedTracker2, _this_perceivedTracker3;
                 // Participant IDs
                 if (state.agent_participant_id) {
@@ -486,6 +504,8 @@ class CallStore {
                 }
                 // Speaking state
                 this.rootStore.setTypingIndicator(state.is_bot_speaking);
+                this.isBotSpeaking.value = state.is_bot_speaking;
+                this.voiceAnswerSequence.value = (_state_voice_answer_seq = state.voice_answer_seq) != null ? _state_voice_answer_seq : null;
                 this.isVisitorSpeaking.value = state.is_user_speaking;
                 (_this_perceivedTracker = this.perceivedTracker) == null ? void 0 : _this_perceivedTracker.setUserSpeaking(state.is_user_speaking);
                 (_this_perceivedTracker1 = this.perceivedTracker) == null ? void 0 : _this_perceivedTracker1.setBotSpeaking(state.is_bot_speaking);
@@ -494,6 +514,7 @@ class CallStore {
             });
             // Terminal states (outside batch since they're async)
             if (state.is_rep_joined && state.call_status === "ended") {
+                this.endPresentationTelemetry();
                 this.handleSwitchToText();
             } else if (state.call_status === "restarting") {
                 if (this.rootStore.isVideoLoading.value || this.dailyCall.value) {
@@ -502,11 +523,20 @@ class CallStore {
             }
         };
         this.handleCallEnded = async ()=>{
+            this.endPresentationTelemetry();
             this.rootStore.setTypingIndicator(false);
             this.teardownAudioAnalyser();
+            this.resetRealtimeSpeechState();
             this.teardownPerceivedVoiceMetric();
             await this.aiConversationStore.handleEndResponse();
         };
+        this.endPresentationTelemetry = ()=>{
+            try {
+                this.rootStore.presentationTelemetryStore.onCallEnded();
+            } catch (unused) {
+            // Presentation telemetry must never prevent call teardown.
+            }
+        };
         this.setupAudioAnalyser = (call)=>{
             try {
                 var _call_participants, _localParticipant_tracks_audio, _localParticipant_tracks;
@@ -543,6 +573,14 @@ class CallStore {
             this.currentAudioTrackId = null;
             this.isVisitorSpeaking.value = false;
         };
+        // Coffee owns these signals, not the local microphone analyser. Replacing a
+        // Daily audio track tears down and rebuilds the analyser during a live call;
+        // clearing Coffee state there would fabricate a silence edge and discard the
+        // monotonic response boundary used to synchronize deck narration.
+        this.resetRealtimeSpeechState = ()=>{
+            this.isBotSpeaking.value = false;
+            this.voiceAnswerSequence.value = null;
+        };
         this.setupPerceivedVoiceMetric = ()=>{
             if (!this.perceivedMetricEnabled || this.perceivedTracker || this.perceivedMetricUnavailable) return;
             try {
@@ -699,7 +737,7 @@ class CallStore {
             }
             this.isHandlingFatalCallEnd = true;
             try {
-                await this.aiConversationStore.endConversation();
+                await this.endCall();
             } catch (error) {
                 var _getSentryClient;
                 (_getSentryClient = getSentryClient({
@@ -726,6 +764,7 @@ class CallStore {
             call.off("error", this.handleError);
             this.voiceGreetingStartTimestamp = null;
             this.teardownAudioAnalyser();
+            this.resetRealtimeSpeechState();
             this.teardownPerceivedVoiceMetric();
             this.userStoppedSpeakingTimestamp = null;
             this._callConnectedEmitted = false;

package/widget/multimodal_v2/stores/call_ui_adapter.js

@@ -86,7 +86,7 @@ import { signals_core_module_w } from "../../../js/multimodal_v2.js";
         },
         endCall: ()=>{
             var _callStore_value;
-            return (_callStore_value = callStore.value) == null ? void 0 : _callStore_value.aiConversationStore.endConversation();
+            return (_callStore_value = callStore.value) == null ? void 0 : _callStore_value.endCall();
         },
         selectMic: (deviceId)=>{
             var _deviceStore_value;