@qualified-salesforce/web 0.0.1-oidc-bootstrap

package/widget/multimodal_v2/stores/call_store.js

@@ -0,0 +1,770 @@
+import { __webpack_require__ } from "../../../js/runtime.js";
+import { Ha } from "../../../js/daily-esm.js";
+import { signals_core_module_r, signals_core_module_d, signals_core_module_w } from "../../../js/multimodal_v2.js";
+import "../../telemetry/index.js";
+import { getSentryClient } from "../../widget/sentry.js";
+import "../constants.js";
+import { resolveBundleBaseUrl } from "../stable_bundle_src.js";
+import { VoiceOnsetDetector } from "../utils/voice_onset_detector.js";
+import { default as AiConversationStore } from "./ai_conversation_store.js";
+import { default as DeviceStore } from "./device_store.js";
+import { default as ParticipantStore } from "./participant_store.js";
+import { ConversationMode as types_ConversationMode, AvatarProvider as types_AvatarProvider } from "../types.js";
+import "../../utils/native_globals.js";
+import { PerceivedVoiceTurnTracker } from "../utils/perceived_voice_turn_tracker.js";
+import { metrics } from "../../telemetry/metrics.js";
+
+/* provided dependency */ var call_store_clearTimeout = __webpack_require__(68034).Kj;
+/* provided dependency */ var call_store_setTimeout = __webpack_require__(68034).pS;
+/* provided dependency */ var __nativeDocumentAddEventListener = __webpack_require__(68034).Qj;
+/* provided dependency */ var __nativeDocumentRemoveEventListener = __webpack_require__(68034).LA;
+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);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+function getCallMachineBundleFilename() {
+    if (typeof __CALL_MACHINE_BUNDLE_FILENAME__ !== "undefined") {
+        return __CALL_MACHINE_BUNDLE_FILENAME__;
+    }
+    return globalThis.__CALL_MACHINE_BUNDLE_FILENAME__;
+}
+/**
+ * A complete call-machine URL, set by the npm package's `setup()` before any call object exists.
+ *
+ * Takes precedence over base-plus-filename resolution because it is the only thing that can be
+ * right when a consumer's bundler re-emitted our asset: measured 2026-08-12, Vite rewrites the
+ * reference to `/assets/call-machine-object-bundle-0.83.1-<hash>.js` and webpack to a bare
+ * `/<hash>.js`, so appending our baked-in filename to either one's directory produces a URL that
+ * does not exist. Read on demand rather than captured, for the same reason the base is — under
+ * unbundled ESM the whole widget graph is evaluated before `setup()` runs a single line.
+ */ function callMachineUrlOverride() {
+    return globalThis.__qualifiedCallMachineUrl;
+}
+/**
+ * Resolves the absolute URL for the call-machine sibling bundle.
+ *
+ * @param filename - The sibling filename (e.g., "call-machine-object-bundle.js")
+ * @param scriptSrc - The src of the currently-loaded script (captured at init time)
+ * @returns Absolute URL to the sibling file, or null if resolution fails
+ */ function resolveCallMachineBundleUrl(filename, scriptSrc) {
+    if (!scriptSrc) return null;
+    try {
+        return new URL(filename, scriptSrc).toString();
+    } catch (unused) {
+        return null;
+    }
+}
+var call_store_CallStatus = /*#__PURE__*/ (/* unused pure expression or super */ null && (function(CallStatus) {
+    CallStatus["CONNECTING"] = "connecting";
+    CallStatus["ACTIVE"] = "active";
+    CallStatus["ENDED"] = "ended";
+    CallStatus["RESTARTING"] = "restarting";
+    return CallStatus;
+}(call_store_CallStatus || {})));
+var call_store_VideoStatus = /*#__PURE__*/ (/* unused pure expression or super */ null && (function(VideoStatus) {
+    VideoStatus["CONNECTING"] = "connecting";
+    VideoStatus["BLURRED"] = "blurred";
+    VideoStatus["ACTIVE"] = "active";
+    VideoStatus["VOICE_ONLY"] = "voice_only";
+    return VideoStatus;
+}(call_store_VideoStatus || {})));
+const CALL_AVAILABILITY_BUDGET_MS = 20000;
+class CallStore {
+    /**
+  * Pre-loads the call object
+  */ preload() {
+        try {
+            this.getOrCreateCallObject();
+        } catch (error) {
+            var _getSentryClient;
+            (_getSentryClient = getSentryClient({
+                project: "multimodal"
+            })) == null ? void 0 : _getSentryClient.captureException(error);
+        }
+    }
+    dispose() {
+        this.aiConversationStore.dispose();
+        // Remove channel event listeners only on full dispose (not on call end)
+        this.rootStore.channel.off("callEnded", this.handleCallEnded);
+        this.rootStore.channel.off("coffeeStateUpdate", this.handleCoffeeStateUpdate);
+        // Fully destroy the call object on dispose
+        this.destroyCallObject();
+        // Reset reconnecting state only on full dispose
+        this.isReconnecting.value = false;
+        this.isSilentRestart.value = false;
+    }
+    /**
+  * Returns the existing Daily call object or creates a new one.
+  * Only one call object is created per session (static singleton).
+  */ getOrCreateCallObject() {
+        if (!this.persistentCallObject) {
+            const dailyConfig = {
+                avoidEval: true
+            };
+            // Only the strict-CSP self-hosted split-css package should resolve the rewritten
+            // call-machine bundle from a sibling file. Hosted snippets must keep using the
+            // backend-provided CDN URL so the bundle is served from assets.qualified... rather
+            // than a js.qualified... snippet host path.
+            const callMachineFilename = getCallMachineBundleFilename();
+            const selfHosted = Boolean(window.__qualifiedSplitCss);
+            // Resolved here rather than read from a module constant: under unbundled ESM the
+            // widget graph is evaluated by static import before `setup()` runs its first line,
+            // so a base URL captured at module-evaluation time can never see the override
+            // `setup()` sets. See stable_bundle_src.ts.
+            const bundleBaseUrl = resolveBundleBaseUrl();
+            const explicitUrl = callMachineUrlOverride();
+            const localBundleUrl = selfHosted ? explicitUrl != null ? explicitUrl : callMachineFilename ? resolveCallMachineBundleUrl(callMachineFilename, bundleBaseUrl) : null : null;
+            // A self-hosted build must serve the call machine from its own origin. Falling
+            // through to the backend-provided URL here looked harmless, because voice kept
+            // working either way — but it sourced 7 MB of executable JS off-origin, and which
+            // origin depended on a feature flag: Qualified's CDN with
+            // `piper_x_use_self_hosted_js` on, and c.daily.co with it off (its declared
+            // default), because the override below is then never set and Daily falls back to
+            // its own hard-coded URL. Both violate the self-hosting requirement and neither
+            // shows up in functional testing, so fail loudly rather than degrade quietly.
+            if (selfHosted && !localBundleUrl) {
+                throw new Error("Qualified: could not resolve the sibling call-machine bundle URL, and refuses " + "to fall back to a remote bundle in a self-hosted build. " + ("(explicitUrl=" + (explicitUrl != null ? explicitUrl : "<unset>") + ", ") + ("filename=" + (callMachineFilename != null ? callMachineFilename : "<unset>") + ", ") + ("baseUrl=" + (bundleBaseUrl != null ? bundleBaseUrl : "<null>") + ")"));
+            }
+            const bundleUrl = localBundleUrl != null ? localBundleUrl : this.rootStore.dailyCallObjectBundleUrl.value;
+            if (bundleUrl) {
+                dailyConfig.callObjectBundleUrlOverride = bundleUrl;
+            }
+            const dailyWsProxyUrl = this.rootStore.dailyWsProxyUrl.value;
+            if (dailyWsProxyUrl) {
+                dailyConfig.proxyUrl = dailyWsProxyUrl;
+            }
+            this.persistentCallObject = Ha.createCallObject({
+                dailyConfig
+            });
+            // Pre-load the call object as soon as it's created to avoid delays when joining a call
+            // No need to await Daily will handle it internally during .join()
+            this.persistentCallObject.load({
+                videoSource: false
+            });
+        }
+        return this.persistentCallObject;
+    }
+    logCoffeeTimingMetrics(state) {
+        const provider = this.rootStore.featureFlags.piperXAnam ? types_AvatarProvider.ANAM : types_AvatarProvider.TAVUS;
+        // Anam: TTS is held until first video frame (= video_status ACTIVE), so gate on that.
+        const isCallActiveForProvider = provider === types_AvatarProvider.ANAM ? state.video_status === "active" : state.call_status === "active";
+        const isSessionConnected = isCallActiveForProvider || state.video_status === "voice_only";
+        if (isSessionConnected && this.aiConversationStore.availabilityTimeoutId !== null) {
+            call_store_clearTimeout(this.aiConversationStore.availabilityTimeoutId);
+            this.aiConversationStore.availabilityTimeoutId = null;
+            metrics.emitIncrement("multimodal_session_connected");
+        }
+        if (state.call_status === "active") {
+            this.resolveCallAvailabilityMetric("success");
+        }
+        // Log time from conversation start to all participants joined (once)
+        if (state.is_participants_joined) {
+            if (!this._callConnectedEmitted) {
+                this._callConnectedEmitted = true;
+                metrics.emitIncrement("multimodal_call_connected");
+            }
+            const startTimestamp = this.aiConversationStore.startConversationTimestamp;
+            if (startTimestamp !== null) {
+                if (this.aiConversationStore.startConversationTimeoutId !== null) {
+                    call_store_clearTimeout(this.aiConversationStore.startConversationTimeoutId);
+                    this.aiConversationStore.startConversationTimeoutId = null;
+                }
+                const deltaMs = performance.now() - startTimestamp;
+                metrics.emitTiming("multimodal_time_to_all_participants_joined_ms", deltaMs);
+                this.voiceGreetingStartTimestamp = startTimestamp;
+                this.aiConversationStore.startConversationTimestamp = null;
+            }
+        }
+        if (!this.isReconnecting.value && !this.isSilentRestart.value) {
+            const startedAt = this.rootStore.callInitiatedAt;
+            if (this._callActiveAt === null && isCallActiveForProvider && startedAt !== null) {
+                this._callActiveAt = performance.now();
+                metrics.emitTiming("multimodal_time_to_call_active_ms", this._callActiveAt - startedAt, {
+                    provider
+                });
+            }
+            // Tavus-only: Anam's call-active is already video_status=ACTIVE, so delta would be ~0.
+            if (provider === types_AvatarProvider.TAVUS && this._videoActiveAt === null && state.video_status === "active" && this._callActiveAt !== null) {
+                this._videoActiveAt = performance.now();
+                metrics.emitTiming("multimodal_call_active_to_video_active_ms", this._videoActiveAt - this._callActiveAt, {
+                    provider
+                });
+            }
+            if (this._vadActiveAt === null && state.is_audio_ready && this._callActiveAt !== null) {
+                this._vadActiveAt = performance.now();
+                metrics.emitTiming("multimodal_call_active_to_vad_active_ms", this._vadActiveAt - this._callActiveAt, {
+                    provider,
+                    voice_greeting_type: this.rootStore.hasCustomVoiceGreeting ? "custom" : "default"
+                });
+            }
+            if (this._initTimeAt === null && startedAt !== null && state.video_status === "active" && state.is_audio_ready) {
+                this._initTimeAt = performance.now();
+                metrics.emitTiming("multimodal_video_init_time_ms", this._initTimeAt - startedAt, {
+                    provider
+                });
+            }
+        }
+        // Log time from participants joined to first bot speaking
+        if (state.is_bot_speaking && this.voiceGreetingStartTimestamp !== null) {
+            const deltaMs = performance.now() - this.voiceGreetingStartTimestamp;
+            metrics.emitTiming("multimodal_voice_greeting_ms", deltaMs);
+            this.voiceGreetingStartTimestamp = null;
+            this.userStoppedSpeakingTimestamp = null;
+        }
+        // Voice response latency: time from user stops speaking to bot starts speaking
+        if (state.is_user_speaking) {
+            this.userStoppedSpeakingTimestamp = null;
+        } else if (this.isVisitorSpeaking.value && !state.is_user_speaking) {
+            this.userStoppedSpeakingTimestamp = performance.now();
+        }
+        if (state.is_bot_speaking && this.userStoppedSpeakingTimestamp !== null) {
+            const deltaMs = performance.now() - this.userStoppedSpeakingTimestamp;
+            metrics.emitTiming("multimodal_voice_response_ms", deltaMs);
+            this.userStoppedSpeakingTimestamp = null;
+        }
+    }
+    get perceivedMetricEnabled() {
+        return this.rootStore.featureFlags.piperXPerceivedVoiceMetric === true;
+    }
+    constructor(rootStore){
+        this.rootStore = rootStore;
+        this.persistentCallObject = null;
+        this.dailyCall = signals_core_module_d(null);
+        this.isJoining = signals_core_module_d(false);
+        this.isJoined = signals_core_module_d(false);
+        this.error = signals_core_module_d(null);
+        this.agentSessionId = signals_core_module_d(null);
+        this.isReconnecting = signals_core_module_d(false);
+        this.isSilentRestart = signals_core_module_d(false);
+        this.voiceGreetingStartTimestamp = null;
+        this.isVisitorSpeaking = signals_core_module_d(false);
+        this.audioAnalyser = signals_core_module_d(null);
+        this.audioContext = null;
+        this.currentAudioTrackId = null;
+        this.userStoppedSpeakingTimestamp = null;
+        this._callConnectedEmitted = false;
+        this._videoActiveAt = null;
+        this._callActiveAt = null;
+        this._vadActiveAt = null;
+        this._initTimeAt = null;
+        this._playbackReadyNotified = false;
+        this.hasConnectedCall = false;
+        this.isHandlingFatalCallEnd = false;
+        this._availabilityTimeoutId = null;
+        this._availabilityResolved = false;
+        this.perceivedDetector = null;
+        this.perceivedTracker = null;
+        this.perceivedBotContext = null;
+        this.perceivedBotAnalyser = null;
+        this.perceivedBotSources = [];
+        this.currentBotTrackKey = null;
+        this.onVisibilityChange = null;
+        this.perceivedMetricUnavailable = false;
+        this.isCoffeeAudioReady = signals_core_module_w(()=>{
+            var _this_aiConversationStore_isCoffeeReady_value;
+            return (_this_aiConversationStore_isCoffeeReady_value = this.aiConversationStore.isCoffeeReady.value) != null ? _this_aiConversationStore_isCoffeeReady_value : false;
+        });
+        this.joinCall = async (roomUrl, token)=>{
+            if (this.dailyCall.value) {
+                return;
+            }
+            metrics.emitIncrement("multimodal_call_initiated");
+            try {
+                this.isJoining.value = true;
+                this.error.value = null;
+                this.perceivedMetricUnavailable = false;
+                // Reuse existing call object or create one if needed
+                const call = this.getOrCreateCallObject();
+                this.dailyCall.value = call;
+                // Attach event listeners
+                call.on("participant-joined", this.participantStore.updateParticipants);
+                call.on("participant-updated", this.handleParticipantUpdated);
+                call.on("participant-left", this.participantStore.updateParticipants);
+                call.on("available-devices-updated", this.deviceStore.updateAvailableDevices);
+                call.on("selected-devices-updated", this.deviceStore.updateAvailableDevices);
+                call.on("error", this.handleError);
+                // TODO: Handle multiple concurrent call checks, see #21276
+                await call.join(_extends({
+                    url: roomUrl
+                }, token && {
+                    token
+                }, {
+                    startAudioOff: true,
+                    startVideoOff: true,
+                    userName: "Visitor"
+                }));
+                this.startAvailabilityTimer();
+                call.setLocalAudio(true);
+                try {
+                    call.updateInputSettings({
+                        audio: {
+                            processor: {
+                                type: "noise-cancellation"
+                            }
+                        }
+                    });
+                } catch (error) {
+                    // eslint-disable-next-line no-console
+                    console.error("Failed to turn on noise cancellation", error);
+                }
+                try {
+                    await this.rootStore.checkPermissions();
+                } catch (permissionError) {
+                    var _getSentryClient;
+                    (_getSentryClient = getSentryClient({
+                        project: "multimodal"
+                    })) == null ? void 0 : _getSentryClient.captureException(permissionError);
+                }
+                // Sync device store with actual call state (needed when reusing call object)
+                this.deviceStore.isMicMuted.value = !call.localAudio();
+                this.deviceStore.updateAvailableDevices();
+            } catch (err) {
+                const alreadyHandled = this.error.value !== null;
+                if (!alreadyHandled) {
+                    var _getSentryClient1;
+                    (_getSentryClient1 = getSentryClient({
+                        project: "multimodal"
+                    })) == null ? void 0 : _getSentryClient1.captureException(err);
+                    if (this.rootStore.featureFlags.piperXAgent) {
+                        metrics.emitIncrement("multimodal_client_error");
+                    }
+                }
+                this.error.value = err instanceof Error ? err.message : "Failed to join call";
+                this.resetCallState();
+            } finally{
+                this.isJoining.value = false;
+            }
+        };
+        this.resetCallAvailabilityMetric = ()=>{
+            this.clearAvailabilityTimer();
+            this._availabilityResolved = false;
+        };
+        this.startAvailabilityTimer = ()=>{
+            this.clearAvailabilityTimer();
+            this._availabilityTimeoutId = call_store_setTimeout(()=>{
+                this._availabilityTimeoutId = null;
+                this.resolveCallAvailabilityMetric("timeout");
+            }, CALL_AVAILABILITY_BUDGET_MS);
+        };
+        this.clearAvailabilityTimer = ()=>{
+            if (this._availabilityTimeoutId !== null) {
+                call_store_clearTimeout(this._availabilityTimeoutId);
+                this._availabilityTimeoutId = null;
+            }
+        };
+        this.resolveCallAvailabilityMetric = (status)=>{
+            if (this._availabilityResolved) return;
+            this._availabilityResolved = true;
+            this.clearAvailabilityTimer();
+            metrics.emitIncrement("multimodal_call_availability", {
+                status
+            });
+        };
+        this.leaveCall = async ()=>{
+            const call = this.dailyCall.value;
+            if (!call) return;
+            try {
+                await call.leave();
+            } catch (unused) {
+            // Ignore leave errors
+            } finally{
+                // Reset call state but keep the call object for reuse
+                this.resetCallState();
+            }
+        };
+        this.handleRestart = async (silent)=>{
+            if (silent === void 0) silent = false;
+            signals_core_module_r(()=>{
+                this.isReconnecting.value = true;
+                this.isSilentRestart.value = silent;
+                this.rootStore.isVideoLoading.value = true;
+                this.rootStore.isBlurredVideoActive.value = false;
+                this.aiConversationStore.isCoffeeReady.value = false;
+            });
+            this.aiConversationStore.endConversation();
+            await this.leaveCall();
+            // Pass !silent as the restart param - silent restarts should show normal greeting
+            this.aiConversationStore.startConversation(!silent);
+        };
+        this.handleParticipantUpdated = ()=>{
+            this.participantStore.updateParticipants();
+            this.deviceStore.syncMediaState();
+            this.notifyPlaybackReady();
+            if (this.dailyCall.value) {
+                var _ref;
+                var _this_dailyCall_value_participants_local_tracks_audio, _this_dailyCall_value_participants_local_tracks, _this_dailyCall_value_participants_local, _this_dailyCall_value_participants;
+                const audioTrack = (_this_dailyCall_value_participants = this.dailyCall.value.participants()) == null ? void 0 : (_this_dailyCall_value_participants_local = _this_dailyCall_value_participants.local) == null ? void 0 : (_this_dailyCall_value_participants_local_tracks = _this_dailyCall_value_participants_local.tracks) == null ? void 0 : (_this_dailyCall_value_participants_local_tracks_audio = _this_dailyCall_value_participants_local_tracks.audio) == null ? void 0 : _this_dailyCall_value_participants_local_tracks_audio.persistentTrack;
+                const trackId = (_ref = audioTrack == null ? void 0 : audioTrack.id) != null ? _ref : null;
+                if (trackId !== this.currentAudioTrackId) {
+                    this.setupAudioAnalyser(this.dailyCall.value);
+                }
+            }
+            if (this.perceivedMetricEnabled && !this.perceivedMetricUnavailable) {
+                this.setupPerceivedVoiceMetric();
+                this.setupPerceivedBotAnalyser();
+            }
+        };
+        // When the coffee agent's audio track becomes renderable on this client (the track the visitor
+        // actually hears), tell the agent so it can release the gated greeting before the opening is
+        // dropped. Flag-gated; a no-op when off.
+        this.notifyPlaybackReady = ()=>{
+            var _this_participantStore_coffeeAgentParticipant_value_tracks_audio, _this_participantStore_coffeeAgentParticipant_value_tracks, _this_participantStore_coffeeAgentParticipant_value;
+            if (this._playbackReadyNotified) return;
+            if (!this.rootStore.featureFlags.piperXGateGreetingOnPlaybackReady) return;
+            const state = (_this_participantStore_coffeeAgentParticipant_value = this.participantStore.coffeeAgentParticipant.value) == null ? void 0 : (_this_participantStore_coffeeAgentParticipant_value_tracks = _this_participantStore_coffeeAgentParticipant_value.tracks) == null ? void 0 : (_this_participantStore_coffeeAgentParticipant_value_tracks_audio = _this_participantStore_coffeeAgentParticipant_value_tracks.audio) == null ? void 0 : _this_participantStore_coffeeAgentParticipant_value_tracks_audio.state;
+            if (state !== "playable") return;
+            this._playbackReadyNotified = true;
+            this.rootStore.channel.perform("notify_playback_ready", {});
+        };
+        this.handleSwitchToText = async ()=>{
+            this.aiConversationStore.endConversation();
+            await this.leaveCall();
+            this.rootStore.setConversationMode(types_ConversationMode.TEXT);
+        };
+        this.handleCoffeeStateUpdate = (state)=>{
+            this.logCoffeeTimingMetrics(state);
+            signals_core_module_r(()=>{
+                var _this_perceivedTracker, _this_perceivedTracker1, _this_perceivedTracker2, _this_perceivedTracker3;
+                // Participant IDs
+                if (state.agent_participant_id) {
+                    this.agentSessionId.value = state.agent_participant_id;
+                }
+                if (state.is_audio_ready) {
+                    this.aiConversationStore.isCoffeeReady.value = true;
+                }
+                // Participants joined
+                if (state.is_participants_joined) {
+                    this.hasConnectedCall = true;
+                    if (this.rootStore.conversationMode.voice.value) {
+                        this.rootStore.isVideoLoading.value = false;
+                    }
+                    this.isReconnecting.value = false;
+                    this.isSilentRestart.value = false;
+                }
+                if (state.avatar_provider !== undefined) {
+                    var _state_avatar_provider;
+                    this.rootStore.activeAvatarProvider.value = (_state_avatar_provider = state.avatar_provider) != null ? _state_avatar_provider : null;
+                }
+                // Video status
+                if (state.video_status === "blurred") {
+                    this.rootStore.isVideoLoading.value = false;
+                    this.rootStore.isBlurredVideoActive.value = true;
+                } else if (state.video_status === "active") {
+                    this.rootStore.isVideoLoading.value = false;
+                    this.rootStore.isBlurredVideoActive.value = false;
+                } else if (state.video_status === "voice_only") {
+                    // Disable video first so voice becomes allowed even on a video-only experience;
+                    // otherwise setConversationMode(VOICE) gets coerced straight back to VIDEO.
+                    this.rootStore.updateConversationModeFailover({
+                        videoDisabled: true
+                    });
+                    this.rootStore.setConversationMode(types_ConversationMode.VOICE);
+                    this.rootStore.isVideoLoading.value = false;
+                    this.rootStore.isBlurredVideoActive.value = false;
+                }
+                // Speaking state
+                this.rootStore.setTypingIndicator(state.is_bot_speaking);
+                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);
+                (_this_perceivedTracker2 = this.perceivedTracker) == null ? void 0 : _this_perceivedTracker2.onAnswerBoundary(state.voice_answer_seq);
+                (_this_perceivedTracker3 = this.perceivedTracker) == null ? void 0 : _this_perceivedTracker3.onServerOutcome(state.voice_turn_outcome, state.voice_turn_token);
+            });
+            // Terminal states (outside batch since they're async)
+            if (state.is_rep_joined && state.call_status === "ended") {
+                this.handleSwitchToText();
+            } else if (state.call_status === "restarting") {
+                if (this.rootStore.isVideoLoading.value || this.dailyCall.value) {
+                    this.handleRestart(true);
+                }
+            }
+        };
+        this.handleCallEnded = async ()=>{
+            this.rootStore.setTypingIndicator(false);
+            this.teardownAudioAnalyser();
+            this.teardownPerceivedVoiceMetric();
+            await this.aiConversationStore.handleEndResponse();
+        };
+        this.setupAudioAnalyser = (call)=>{
+            try {
+                var _call_participants, _localParticipant_tracks_audio, _localParticipant_tracks;
+                const localParticipant = (_call_participants = call.participants()) == null ? void 0 : _call_participants.local;
+                const audioTrack = localParticipant == null ? void 0 : (_localParticipant_tracks = localParticipant.tracks) == null ? void 0 : (_localParticipant_tracks_audio = _localParticipant_tracks.audio) == null ? void 0 : _localParticipant_tracks_audio.persistentTrack;
+                if (!audioTrack) return;
+                this.teardownAudioAnalyser();
+                this.currentAudioTrackId = audioTrack.id;
+                this.audioContext = new AudioContext();
+                if (this.audioContext.state === "suspended") {
+                    void this.audioContext.resume().catch(()=>{});
+                }
+                const source = this.audioContext.createMediaStreamSource(new MediaStream([
+                    audioTrack
+                ]));
+                const analyser = this.audioContext.createAnalyser();
+                analyser.fftSize = 256;
+                analyser.smoothingTimeConstant = 0.4;
+                source.connect(analyser);
+                this.audioAnalyser.value = analyser;
+            } catch (unused) {
+                var _this_audioContext;
+                (_this_audioContext = this.audioContext) == null ? void 0 : _this_audioContext.close();
+                this.audioContext = null;
+                this.audioAnalyser.value = null;
+                this.currentAudioTrackId = null;
+            }
+        };
+        this.teardownAudioAnalyser = ()=>{
+            var _this_audioContext;
+            (_this_audioContext = this.audioContext) == null ? void 0 : _this_audioContext.close();
+            this.audioContext = null;
+            this.audioAnalyser.value = null;
+            this.currentAudioTrackId = null;
+            this.isVisitorSpeaking.value = false;
+        };
+        this.setupPerceivedVoiceMetric = ()=>{
+            if (!this.perceivedMetricEnabled || this.perceivedTracker || this.perceivedMetricUnavailable) return;
+            try {
+                const provider = this.rootStore.featureFlags.piperXAnam ? "anam" : "tavus";
+                this.perceivedTracker = new PerceivedVoiceTurnTracker({
+                    budgetMs: (/* inlined export .RESPONSE_BUDGET_MS */25000),
+                    emitTurn: (status)=>metrics.emitIncrement("multimodal_voice_perceived_turn", {
+                            status,
+                            provider
+                        }),
+                    emitLatency: (ms)=>metrics.emitTiming("multimodal_voice_perceived_response_ms", ms, {
+                            provider
+                        })
+                });
+                this.perceivedDetector = new VoiceOnsetDetector({
+                    getMicAnalyser: ()=>this.audioAnalyser.value,
+                    getBotAnalyser: ()=>this.perceivedBotAnalyser,
+                    callbacks: {
+                        onMicQuiet: (ts)=>{
+                            var _this_perceivedTracker;
+                            return (_this_perceivedTracker = this.perceivedTracker) == null ? void 0 : _this_perceivedTracker.onMicQuiet(ts);
+                        },
+                        onMicActive: (ts)=>{
+                            var _this_perceivedTracker;
+                            return (_this_perceivedTracker = this.perceivedTracker) == null ? void 0 : _this_perceivedTracker.onMicActive(ts);
+                        },
+                        onBotOnset: (ts)=>{
+                            var _this_perceivedTracker;
+                            return (_this_perceivedTracker = this.perceivedTracker) == null ? void 0 : _this_perceivedTracker.onBotOnset(ts);
+                        },
+                        onBotSilence: (ts)=>{
+                            var _this_perceivedTracker;
+                            return (_this_perceivedTracker = this.perceivedTracker) == null ? void 0 : _this_perceivedTracker.onBotSilence(ts);
+                        }
+                    }
+                });
+                this.perceivedDetector.start();
+                this.onVisibilityChange = ()=>{
+                    var _this_perceivedTracker;
+                    if (document.visibilityState === "hidden") (_this_perceivedTracker = this.perceivedTracker) == null ? void 0 : _this_perceivedTracker.onHidden();
+                };
+                __nativeDocumentAddEventListener("visibilitychange", this.onVisibilityChange);
+            } catch (unused) {
+                this.teardownPerceivedVoiceMetric();
+            }
+        };
+        // At most one bot AudioContext is ever created here; never mutates the mic analyser's config.
+        // The audible bot audio can be on EITHER the coffee-agent track OR the Tavus avatar ("Tavus Echo
+        // Audio Stream") track, and which one is live varies by provider and — on the tavus_stream_audio
+        // path — per-utterance/failover state (coffee routes voice-mode audio on its own track and
+        // echo-mode audio through the avatar). So we feed *every* present bot track into ONE analyser and
+        // let an onset on either fire; this mirrors what the widget plays and the orb monitors, and can't
+        // silently mis-tap on failover. Rebuild only when the set of track ids actually changes (repeated
+        // participant-updated events with the same tracks are no-ops), disconnecting the previous sources
+        // first so track changes don't leak orphaned nodes into the persistent context.
+        this.setupPerceivedBotAnalyser = ()=>{
+            try {
+                var _ref, _ref1, _this_perceivedBotContext;
+                var _this_participantStore_avatarParticipant_value_tracks_audio, _this_participantStore_avatarParticipant_value_tracks, _this_participantStore_avatarParticipant_value, _this_participantStore_coffeeAgentParticipant_value_tracks_audio, _this_participantStore_coffeeAgentParticipant_value_tracks, _this_participantStore_coffeeAgentParticipant_value;
+                const avatarTrack = (_ref = (_this_participantStore_avatarParticipant_value = this.participantStore.avatarParticipant.value) == null ? void 0 : (_this_participantStore_avatarParticipant_value_tracks = _this_participantStore_avatarParticipant_value.tracks) == null ? void 0 : (_this_participantStore_avatarParticipant_value_tracks_audio = _this_participantStore_avatarParticipant_value_tracks.audio) == null ? void 0 : _this_participantStore_avatarParticipant_value_tracks_audio.persistentTrack) != null ? _ref : null;
+                const coffeeTrack = (_ref1 = (_this_participantStore_coffeeAgentParticipant_value = this.participantStore.coffeeAgentParticipant.value) == null ? void 0 : (_this_participantStore_coffeeAgentParticipant_value_tracks = _this_participantStore_coffeeAgentParticipant_value.tracks) == null ? void 0 : (_this_participantStore_coffeeAgentParticipant_value_tracks_audio = _this_participantStore_coffeeAgentParticipant_value_tracks.audio) == null ? void 0 : _this_participantStore_coffeeAgentParticipant_value_tracks_audio.persistentTrack) != null ? _ref1 : null;
+                const tracks = [
+                    avatarTrack,
+                    coffeeTrack
+                ].filter((t)=>t != null);
+                if (tracks.length === 0) return;
+                const key = tracks.map((t)=>t.id).join("|");
+                if (key === this.currentBotTrackKey) return;
+                (_this_perceivedBotContext = this.perceivedBotContext) != null ? _this_perceivedBotContext : this.perceivedBotContext = new AudioContext();
+                // A context created off an async participant event may start suspended under autoplay
+                // policy; a suspended context yields silent analyser frames, so onsets never fire and every
+                // heard answer looks like `not_heard`. Resume best-effort (mirrors useAudioLevelMonitoring).
+                if (this.perceivedBotContext.state === "suspended") {
+                    void this.perceivedBotContext.resume().catch(()=>{});
+                }
+                // Break the previous graph before rebuilding so a track change (reconnect/failover) doesn't
+                // leak orphaned source nodes into the persistent context.
+                this.disconnectPerceivedBotNodes();
+                const analyser = this.perceivedBotContext.createAnalyser();
+                analyser.fftSize = 256;
+                analyser.smoothingTimeConstant = 0.4;
+                for (const track of tracks){
+                    const source = this.perceivedBotContext.createMediaStreamSource(new MediaStream([
+                        track
+                    ]));
+                    source.connect(analyser);
+                    this.perceivedBotSources.push(source);
+                }
+                this.perceivedBotAnalyser = analyser;
+                this.currentBotTrackKey = key;
+            } catch (unused) {
+                // A genuine Web Audio failure (not the normal "track not ready yet", which returns early
+                // above): tearing down beats running the tracker + budget with a null analyser, which would
+                // classify every real answer as `not_heard` and depress the SLI. Disable for the session.
+                this.perceivedMetricUnavailable = true;
+                this.teardownPerceivedVoiceMetric();
+            }
+        };
+        this.disconnectPerceivedBotNodes = ()=>{
+            for (const source of this.perceivedBotSources){
+                try {
+                    source.disconnect();
+                } catch (unused) {
+                /* already disconnected */ }
+            }
+            this.perceivedBotSources = [];
+            try {
+                var _this_perceivedBotAnalyser;
+                (_this_perceivedBotAnalyser = this.perceivedBotAnalyser) == null ? void 0 : _this_perceivedBotAnalyser.disconnect();
+            } catch (unused) {
+            /* already disconnected */ }
+        };
+        this.teardownPerceivedVoiceMetric = ()=>{
+            try {
+                var _this_perceivedDetector, _this_perceivedTracker, _this_perceivedBotContext;
+                (_this_perceivedDetector = this.perceivedDetector) == null ? void 0 : _this_perceivedDetector.stop();
+                (_this_perceivedTracker = this.perceivedTracker) == null ? void 0 : _this_perceivedTracker.dispose();
+                this.disconnectPerceivedBotNodes();
+                (_this_perceivedBotContext = this.perceivedBotContext) == null ? void 0 : _this_perceivedBotContext.close();
+                if (this.onVisibilityChange) {
+                    __nativeDocumentRemoveEventListener("visibilitychange", this.onVisibilityChange);
+                }
+            } catch (unused) {
+            /* ignore */ } finally{
+                this.perceivedDetector = null;
+                this.perceivedTracker = null;
+                this.perceivedBotContext = null;
+                this.perceivedBotAnalyser = null;
+                this.perceivedBotSources = [];
+                this.currentBotTrackKey = null;
+                this.onVisibilityChange = null;
+            }
+        };
+        // Private methods
+        this.handleTavusConversationChange = (conversation)=>{
+            if ((conversation == null ? void 0 : conversation.conversation_url) && !this.dailyCall.value) {
+                this.joinCall(conversation.conversation_url, conversation.visitor_token);
+            }
+        };
+        this.handleError = (event)=>{
+            var _getSentryClient;
+            (_getSentryClient = getSentryClient({
+                project: "multimodal"
+            })) == null ? void 0 : _getSentryClient.captureException(event);
+            if (this.rootStore.featureFlags.piperXAgent) {
+                metrics.emitIncrement("multimodal_client_error");
+            }
+            this.error.value = event.errorMsg || "Call error occurred";
+            void this.handleFatalActiveCallEnd();
+        };
+        this.handleFatalActiveCallEnd = async ()=>{
+            if (!this.hasConnectedCall || this.isReconnecting.value || this.isHandlingFatalCallEnd || !this.aiConversationStore.conversation.value) {
+                return;
+            }
+            this.isHandlingFatalCallEnd = true;
+            try {
+                await this.aiConversationStore.endConversation();
+            } catch (error) {
+                var _getSentryClient;
+                (_getSentryClient = getSentryClient({
+                    project: "multimodal"
+                })) == null ? void 0 : _getSentryClient.captureException(error);
+            } finally{
+                this.isHandlingFatalCallEnd = false;
+            }
+        };
+        /**
+    * Resets call-related state without destroying the call object.
+    * Used when leaving a call but wanting to rejoin later in the same session.
+    */ this.resetCallState = ()=>{
+            this.hasConnectedCall = false;
+            this.clearAvailabilityTimer();
+            // Detach event listeners before resetting state
+            const call = this.dailyCall.value;
+            if (!call) return;
+            call.off("participant-joined", this.participantStore.updateParticipants);
+            call.off("participant-updated", this.handleParticipantUpdated);
+            call.off("participant-left", this.participantStore.updateParticipants);
+            call.off("available-devices-updated", this.deviceStore.updateAvailableDevices);
+            call.off("selected-devices-updated", this.deviceStore.updateAvailableDevices);
+            call.off("error", this.handleError);
+            this.voiceGreetingStartTimestamp = null;
+            this.teardownAudioAnalyser();
+            this.teardownPerceivedVoiceMetric();
+            this.userStoppedSpeakingTimestamp = null;
+            this._callConnectedEmitted = false;
+            this._videoActiveAt = null;
+            this._callActiveAt = null;
+            this._vadActiveAt = null;
+            this._initTimeAt = null;
+            this._playbackReadyNotified = false;
+            this.rootStore.callInitiatedAt = null;
+            signals_core_module_r(()=>{
+                this.dailyCall.value = null;
+                this.isJoined.value = false;
+                this.isJoining.value = false;
+                this.aiConversationStore.isCoffeeReady.value = false;
+                this.agentSessionId.value = null;
+                this.rootStore.isBlurredVideoActive.value = false;
+                this.participantStore.dispose();
+                this.deviceStore.dispose();
+            });
+        };
+        /**
+    * Fully destroys the Daily call object and cleans up all resources.
+    * Called only on full dispose of the CallStore.
+    */ this.destroyCallObject = ()=>{
+            // resetCallState will detach event listeners using persistentCallObject
+            this.resetCallState();
+            if (this.persistentCallObject) {
+                this.persistentCallObject.destroy();
+                this.persistentCallObject = null;
+            }
+        };
+        this.aiConversationStore = new AiConversationStore(this);
+        this.aiConversationStore.conversation.subscribe(this.handleTavusConversationChange);
+        this.participantStore = new ParticipantStore(this);
+        this.deviceStore = new DeviceStore(this);
+        this.rootStore.channel.on("callEnded", this.handleCallEnded);
+        this.rootStore.channel.on("coffeeStateUpdate", this.handleCoffeeStateUpdate);
+    }
+}
+
+
+export default CallStore;