@qualified-salesforce/web 0.0.1-oidc-bootstrap

package/widget/multimodal_v2/stores/decks_store.js

@@ -0,0 +1,285 @@
+import { __webpack_require__ } from "../../../js/runtime.js";
+import { signals_core_module_E, signals_core_module_d, signals_core_module_w } from "../../../js/multimodal_v2.js";
+import "../../utils/native_globals.js";
+
+/* provided dependency */ var decks_store_setTimeout = __webpack_require__(68034).pS;
+/* provided dependency */ var decks_store_clearTimeout = __webpack_require__(68034).Kj;
+
+// Floor for how long a slide stays up before auto-advancing. A slide whose
+// talk-track generation failed has an estimated duration of 0; without a floor
+// setTimeout(…, 0) would flash through the whole sequence instantly.
+const MIN_SLIDE_DURATION_MS = 2000;
+class DecksStore {
+    dispose() {
+        this.unsubscribeArtifact == null ? void 0 : this.unsubscribeArtifact.call(this);
+        this.unsubscribeArtifact = null;
+        this.disposeInterruptEffect == null ? void 0 : this.disposeInterruptEffect.call(this);
+        this.disposeInterruptEffect = null;
+        this.disposeTextInterruptEffect == null ? void 0 : this.disposeTextInterruptEffect.call(this);
+        this.disposeTextInterruptEffect = null;
+        this.clearAdvanceTimer();
+    }
+    // Show a single slide statically (visitor clicked it in the transcript record).
+    // Set the revisit target before the artifact overlay opens so the artifact
+    // subscription treats the open as a revisit rather than a fresh presentation.
+    prepareRevisit(messageId, slideIndex, pageTitle) {
+        this.clearAdvanceTimer();
+        this.stopped.value = true;
+        this.revisitMessageId = messageId;
+        // Set the title before the index signal, which triggers the currentDeck recompute.
+        this.revisitPageTitle = pageTitle;
+        this.revisitIndex.value = slideIndex;
+    }
+    isRevisiting(messageId) {
+        return this.revisitMessageId === messageId && this.revisitIndex.peek() != null;
+    }
+    // Fire-and-forget the current on-screen slide + the full sequence to the backend,
+    // which computes the remaining slides and seeds the agent's context. The early
+    // return in handleInterruption (guarding on `stopped`) makes this fire exactly
+    // once per guided run; a new deck message resets `stopped` so a later resume can
+    // be interrupted and re-report.
+    notifyInterruption(message) {
+        var _ref, _message_slides;
+        var _message_slides1;
+        const current = this.currentDeck.value;
+        if (!current) return;
+        if (!message.autoAdvance || ((_ref = (_message_slides1 = message.slides) == null ? void 0 : _message_slides1.length) != null ? _ref : 0) <= 1) return;
+        if (current.sequencePosition >= current.sequenceLength - 1) return;
+        this.rootStore.channel.perform("notify_deck_interrupted", {
+            deck_id: message.deckId,
+            current_slide_index: current.currentIndex,
+            sequence_slide_indexes: ((_message_slides = message.slides) != null ? _message_slides : []).map((slide)=>slide.slideIndex)
+        });
+    }
+    scheduleAdvance(slides) {
+        var _ref;
+        var _slides_, _slides_position;
+        if (this.stopped.value) return; // visitor interrupted — do not advance
+        const position = this.playbackIndex.value;
+        if (position >= slides.length - 1) return; // last slide — stop advancing
+        // Warm the browser cache for the next slide's image now, while the current one
+        // is on screen, so the auto-advance swap doesn't flash a blank/stale frame
+        // while the full-res PDF page downloads (narration keeps pace regardless).
+        this.preloadImage((_slides_ = slides[position + 1]) == null ? void 0 : _slides_.imageUrl);
+        // Each slide stays up for as long as its talk track takes to narrate, but
+        // never less than the floor (a failed talk track estimates to 0ms).
+        const durationMs = Math.max((_ref = (_slides_position = slides[position]) == null ? void 0 : _slides_position.estimatedDurationMs) != null ? _ref : 0, MIN_SLIDE_DURATION_MS);
+        this.advanceTimerId = decks_store_setTimeout(()=>{
+            this.advanceTimerId = null;
+            if (this.stopped.value) return;
+            this.playbackIndex.value = Math.min(this.playbackIndex.value + 1, slides.length - 1);
+            this.scheduleAdvance(slides);
+        }, durationMs);
+    }
+    clearRevisit() {
+        this.revisitMessageId = null;
+        this.revisitIndex.value = null;
+        this.revisitPageTitle = undefined;
+    }
+    clearAdvanceTimer() {
+        if (this.advanceTimerId !== null) {
+            decks_store_clearTimeout(this.advanceTimerId);
+            this.advanceTimerId = null;
+        }
+    }
+    // Kick off a background fetch of an image URL so it's cached before it's shown. Crossorigin
+    // like every other slide load, so this warm-up can't be the one that caches an ACAO-less
+    // response and poisons the entry the visible <img> needs.
+    preloadImage(url) {
+        if (!url || typeof Image === "undefined") return;
+        const img = new Image();
+        img.crossOrigin = "anonymous";
+        img.src = url;
+    }
+    constructor(rootStore){
+        var _ref;
+        var _latestVisitorText;
+        this.rootStore = rootStore;
+        // Derived state: the deck slide currently presented in the ARTIFACT overlay.
+        //
+        // A single share_deck tool call can present one slide or an auto-advancing
+        // sequence. The slide on screen is `slides[playbackIndex]`; for legacy/single
+        // messages the index comes straight from the message.
+        this.currentDeck = signals_core_module_w(()=>{
+            var _ref, _ref1, _ref2;
+            var _message_slideImageUrls;
+            const message = this.rootStore.artifact.message.value;
+            if (!message || message.type !== "present_deck") return null;
+            const slideImageUrls = ((_message_slideImageUrls = message.slideImageUrls) == null ? void 0 : _message_slideImageUrls.length) > 0 ? message.slideImageUrls : [
+                message.imageUrl
+            ];
+            // Revisit: the visitor clicked a slide in the transcript record. Show that
+            // single slide statically (no auto-advance, no progress dots).
+            const revisitIndex = this.revisitIndex.value;
+            if (revisitIndex != null) {
+                var _ref3, _this_revisitPageTitle;
+                var _message_slides_find, _message_slides;
+                return {
+                    deckId: message.deckId,
+                    slideImageUrls,
+                    currentIndex: clampIndex(revisitIndex, slideImageUrls.length),
+                    sequencePosition: 0,
+                    sequenceLength: 1,
+                    pageTitle: (_ref3 = (_this_revisitPageTitle = this.revisitPageTitle) != null ? _this_revisitPageTitle : (_message_slides = message.slides) == null ? void 0 : (_message_slides_find = _message_slides.find((slide)=>slide.slideIndex === revisitIndex)) == null ? void 0 : _message_slides_find.pageTitle) != null ? _ref3 : message.pageTitle,
+                    deckTitle: message.deckTitle
+                };
+            }
+            const sequence = this.sequence.value;
+            const position = clampIndex(this.playbackIndex.value, sequence.length);
+            const slide = sequence[position];
+            const slideIndex = (_ref = (_ref1 = slide == null ? void 0 : slide.slideIndex) != null ? _ref1 : message.slideIndex) != null ? _ref : 0;
+            return {
+                deckId: message.deckId,
+                slideImageUrls,
+                currentIndex: clampIndex(slideIndex, slideImageUrls.length),
+                sequencePosition: position,
+                sequenceLength: sequence.length,
+                pageTitle: (_ref2 = slide == null ? void 0 : slide.pageTitle) != null ? _ref2 : message.pageTitle,
+                deckTitle: message.deckTitle
+            };
+        });
+        // Everything below is private
+        // 0-based position within the active sequence.
+        this.playbackIndex = signals_core_module_d(0);
+        // Set once the visitor interrupts; halts auto-advancing.
+        this.stopped = signals_core_module_d(false);
+        this.advanceTimerId = null;
+        this.lastHandledMessageId = null;
+        // Set when the visitor clicks a slide in the transcript record to revisit it.
+        // While set, `currentDeck` shows that single slide statically. Cleared when a
+        // new/different deck message becomes the active artifact.
+        this.revisitIndex = signals_core_module_d(null);
+        this.revisitMessageId = null;
+        // The clicked slide's title, passed through from the transcript record so a
+        // revisit shows the right title even when the active message (the last share)
+        // doesn't contain that slide. Cleared alongside the revisit state.
+        this.revisitPageTitle = undefined;
+        this.unsubscribeArtifact = null;
+        this.disposeInterruptEffect = null;
+        this.disposeTextInterruptEffect = null;
+        // Id of the most recent visitor text message we've already accounted for, so a
+        // text-mode interruption only fires for a genuinely new message.
+        this.lastVisitorTextMessageId = null;
+        // The ordered slides to present for the active deck message. Falls back to a
+        // synthesized one-item sequence for legacy messages without a `slides` array.
+        this.sequence = signals_core_module_w(()=>{
+            var _message_slideIndex;
+            var _message_slides;
+            const message = this.rootStore.artifact.message.value;
+            if (!message || message.type !== "present_deck") return [];
+            if ((_message_slides = message.slides) == null ? void 0 : _message_slides.length) return message.slides;
+            return [
+                {
+                    pageId: message.pageId,
+                    slideIndex: (_message_slideIndex = message.slideIndex) != null ? _message_slideIndex : 0,
+                    imageUrl: message.imageUrl,
+                    pageTitle: message.pageTitle
+                }
+            ];
+        });
+        this.handleArtifactMessageChange = (message)=>{
+            var _ref;
+            var _message_slides;
+            if (!message || message.type !== "present_deck") {
+                this.clearAdvanceTimer();
+                this.lastHandledMessageId = null;
+                this.playbackIndex.value = 0;
+                this.clearRevisit();
+                return;
+            }
+            // A revisit open (prepareRevisit set revisitMessageId first): show the
+            // requested slide statically — don't reset playback or auto-advance.
+            if (message.id === this.revisitMessageId) {
+                this.clearAdvanceTimer();
+                this.lastHandledMessageId = message.id;
+                this.stopped.value = true;
+                return;
+            }
+            // Skip if we've already handled this exact message. The subscription
+            // re-fires whenever the message object is replaced under the same id — an
+            // unrelated upstream signal re-resolving, or the server re-broadcasting the
+            // deck once its narration transcript is absorbed
+            // (Internal::PyperxController#absorb_deck_narration!). Return BEFORE
+            // touching the advance timer: clearing it here would freeze an in-flight
+            // presentation on the current slide with nothing left to reschedule it.
+            if (this.lastHandledMessageId === message.id) return;
+            this.clearAdvanceTimer();
+            // Any other deck message supersedes a revisit view.
+            this.clearRevisit();
+            this.lastHandledMessageId = message.id;
+            this.playbackIndex.value = 0;
+            this.stopped.value = false;
+            // Auto-advance through a multi-slide sequence so the agent can present it as
+            // one continuous flow without re-calling the tool for each slide.
+            if (message.autoAdvance && ((_ref = (_message_slides = message.slides) == null ? void 0 : _message_slides.length) != null ? _ref : 0) > 1) {
+                var _message_slides1;
+                this.scheduleAdvance((_message_slides1 = message.slides) != null ? _message_slides1 : []);
+            }
+        };
+        // The visitor started speaking over the presentation. Stop advancing; the current
+        // slide stays on screen, and tell the agent where the presentation stopped so it
+        // can address the visitor and later resume the remaining slides.
+        this.handleInterruption = ()=>{
+            if (this.stopped.value) return;
+            const message = this.rootStore.artifact.message.value;
+            if ((message == null ? void 0 : message.type) !== "present_deck") return;
+            // Report the interruption position BEFORE we stop, so the agent knows which
+            // slide is frozen on screen and which slides remain. Only worth reporting for a
+            // multi-slide auto-advancing sequence with unshown slides left — single-slide
+            // narration is agent-driven and the last slide has nothing to resume.
+            this.notifyInterruption(message);
+            this.clearAdvanceTimer();
+            this.stopped.value = true;
+        };
+        this.unsubscribeArtifact = this.rootStore.artifact.message.subscribe(this.handleArtifactMessageChange);
+        // Halt the presentation the moment the visitor starts speaking (interruption):
+        // stop auto-advancing slides. We don't resume — an interruption ends the guided run.
+        this.disposeInterruptEffect = signals_core_module_E(()=>{
+            var _ref;
+            var _this_rootStore_callStore_value_isVisitorSpeaking, _this_rootStore_callStore_value, _this_rootStore_callStore;
+            const speaking = (_ref = (_this_rootStore_callStore = this.rootStore.callStore) == null ? void 0 : (_this_rootStore_callStore_value = _this_rootStore_callStore.value) == null ? void 0 : (_this_rootStore_callStore_value_isVisitorSpeaking = _this_rootStore_callStore_value.isVisitorSpeaking) == null ? void 0 : _this_rootStore_callStore_value_isVisitorSpeaking.value) != null ? _ref : false;
+            if (speaking) this.handleInterruption();
+        });
+        // A visitor text message sent mid-presentation is a text-mode interruption and
+        // must have the same effect as speaking over the deck (barge-in): the backend
+        // already cancels the agent's turn to answer the text, so here we halt
+        // auto-advance and report the interruption position exactly as the voice path
+        // does. Seed lastVisitorTextMessageId from the existing history so we only
+        // react to a message sent AFTER this store is watching, not to backlog.
+        this.lastVisitorTextMessageId = (_ref = (_latestVisitorText = latestVisitorText(this.rootStore.messages.value)) == null ? void 0 : _latestVisitorText.id) != null ? _ref : null;
+        this.disposeTextInterruptEffect = signals_core_module_E(()=>{
+            const latest = latestVisitorText(this.rootStore.messages.value);
+            if (!latest || latest.id === this.lastVisitorTextMessageId) return;
+            this.lastVisitorTextMessageId = latest.id;
+            // In voice mode the visitor's spoken utterance is also persisted as a
+            // visitor text message, out-of-band and often AFTER the deck message it
+            // requested ("let's continue the presentation") — with createdAt
+            // backdated to when it was spoken. A message older than the deck on
+            // screen is that late-arriving request, not an interruption OF the
+            // presentation, and must not halt it. peek(): the deck message is
+            // read as a point-in-time fact about the new text message, not a
+            // subscription — this effect must only re-run when the messages change.
+            const deckMessage = this.rootStore.artifact.message.peek();
+            if ((deckMessage == null ? void 0 : deckMessage.type) === "present_deck" && new Date(latest.createdAt).getTime() < new Date(deckMessage.createdAt).getTime()) {
+                return;
+            }
+            this.handleInterruption();
+        });
+    }
+}
+
+function clampIndex(index, length) {
+    if (length <= 0) return 0;
+    return Math.min(Math.max(index, 0), length - 1);
+}
+// The most recent visitor-authored text message in the list, or null if there
+// is none. Used to detect a text-mode interruption of a live deck.
+function latestVisitorText(messages) {
+    for(let i = messages.length - 1; i >= 0; i--){
+        const message = messages[i];
+        if (message.type === "text" && message.isOwn) return message;
+    }
+    return null;
+}
+
+export default DecksStore;

package/widget/multimodal_v2/stores/device_store.js

@@ -0,0 +1,63 @@
+import { signals_core_module_r, signals_core_module_d } from "../../../js/multimodal_v2.js";
+
+
+class DeviceStore {
+    dispose() {
+        this.microphoneDevices.value = [];
+        this.selectedMicrophoneDevice.value = {};
+        this.isMicMuted.value = false;
+    }
+    // eslint-disable-next-line no-useless-constructor
+    constructor(callStore){
+        this.callStore = callStore;
+        this.microphoneDevices = signals_core_module_d([]);
+        this.selectedMicrophoneDevice = signals_core_module_d({});
+        this.isMicMuted = signals_core_module_d(false);
+        this.toggleMic = async ()=>{
+            const call = this.callStore.dailyCall.value;
+            if (!call) return;
+            const newMicState = !this.callStore.deviceStore.isMicMuted.value;
+            call.setLocalAudio(!newMicState);
+            this.callStore.deviceStore.isMicMuted.value = newMicState;
+        };
+        this.updateSelectedMic = async (updatedMicId)=>{
+            const call = this.callStore.dailyCall.value;
+            if (!call) return;
+            try {
+                await call.setInputDevicesAsync({
+                    audioDeviceId: updatedMicId,
+                    videoDeviceId: null
+                });
+                const updatedSelectedMic = this.microphoneDevices.value.find((mic)=>mic.deviceId === updatedMicId);
+                signals_core_module_r(()=>{
+                    this.selectedMicrophoneDevice.value = updatedSelectedMic || {};
+                });
+            } catch (error) {
+                // eslint-disable-next-line no-console
+                console.error("Failed to update selected microphone:", error);
+            }
+        };
+        this.updateAvailableDevices = async ()=>{
+            const call = this.callStore.dailyCall.value;
+            if (!call) return;
+            const { devices } = await call.enumerateDevices();
+            // filter out empty devices that have not been granted yet
+            const availableDevices = devices.filter((device)=>device.deviceId !== "");
+            const availableMicrophones = availableDevices.filter((device)=>device.kind === "audioinput");
+            const selectedDevices = await call.getInputDevices();
+            const selectedMicrophone = selectedDevices.mic;
+            signals_core_module_r(()=>{
+                this.microphoneDevices.value = availableMicrophones;
+                this.selectedMicrophoneDevice.value = selectedMicrophone;
+            });
+        };
+        this.syncMediaState = ()=>{
+            const call = this.callStore.dailyCall.value;
+            if (!call) return;
+            this.isMicMuted.value = !call.localAudio();
+        };
+    }
+}
+
+
+export default DeviceStore;

package/widget/multimodal_v2/stores/docking_store.js

@@ -0,0 +1,62 @@
+import { BaseStore } from "./base_store.js";
+
+
+class DockingStore extends BaseStore {
+    constructor(...args){
+        var _ref;
+        var _window_qualified;
+        super(...args), this.api = (_ref = (_window_qualified = window.qualified) == null ? void 0 : _window_qualified.docking) != null ? _ref : null, this.apiPromise = null, // (e.g. teardown ran while enable() was still awaiting ensureApi()).
+        this.generation = 0, this.enable = async (param)=>{
+            let { confirm = ()=>true } = param === void 0 ? {} : param;
+            const gen = this.generation;
+            const api = await this.ensureApi();
+            if (gen !== this.generation) return;
+            if (confirm()) {
+                api.enable();
+                this.persistDockedState(true);
+            }
+        }, this.disable = ()=>{
+            this.generation++;
+            if (!this.api) return;
+            this.api.disable();
+            this.persistDockedState(false);
+        }, this.reEvaluate = ()=>{
+            var _this_api;
+            (_this_api = this.api) == null ? void 0 : _this_api.reEvaluate();
+        }, this.isDocked = ()=>{
+            var _ref;
+            var _this_api;
+            return (_ref = (_this_api = this.api) == null ? void 0 : _this_api.isDocked()) != null ? _ref : false;
+        }, this.cancelAbort = ()=>{
+            var _this_api;
+            (_this_api = this.api) == null ? void 0 : _this_api.cancelAbort();
+        }, this.persistDockedState = (isDocked)=>{
+            this.visitor.isDocked = isDocked;
+        }, this.ensureApi = ()=>{
+            if (this.apiPromise) return this.apiPromise;
+            const ensureApiInitialized = ()=>{
+                var _window_qualified;
+                this.api = (_window_qualified = window.qualified) == null ? void 0 : _window_qualified.docking;
+                // Calling init multiple times is safe
+                this.api.init();
+                this.cancelAbort();
+                return this.api;
+            };
+            this.apiPromise = new Promise((resolve)=>{
+                var _window_qualified;
+                if ((_window_qualified = window.qualified) == null ? void 0 : _window_qualified.docking) {
+                    resolve(ensureApiInitialized());
+                    return;
+                }
+                import("../../../packs/widget/api/docking/index.js").then((param)=>{
+                    let { registerDockingAPI } = param;
+                    registerDockingAPI();
+                    resolve(ensureApiInitialized());
+                });
+            });
+            return this.apiPromise;
+        };
+    }
+}
+
+export { DockingStore };