@pendo/agent 2.328.2 → 2.329.0

package/dist/pendo.module.js

@@ -4010,8 +4010,8 @@ let SERVER = '';
 let ASSET_HOST = '';
 let ASSET_PATH = '';
 let DESIGNER_SERVER = '';
-let VERSION = '2.328.2_';
-let PACKAGE_VERSION = '2.328.2';
+let VERSION = '2.329.0_';
+let PACKAGE_VERSION = '2.329.0';
 let LOADER = 'xhr';
 /* eslint-enable web-sdk-eslint-rules/no-gulp-env-references */
 /**
@@ -20097,6 +20097,7 @@ var GuideStateModule = (function () {
         storageKey: LAST_STEP_ADVANCED_COOKIE,
         guideRequestExpiration: 60 * 60 * 1000,
         scopedStorageKey: null,
+        scopedThrottlingStorageKeys: {},
         receivedStateChangeAt: null,
         receivedLastGuideStepSeen: null,
         lastGuideStepSeen: null,
@@ -20119,6 +20120,11 @@ var GuideStateModule = (function () {
             */
             context.getters.storage().registry.addLocal(LAST_STEP_ADVANCED_COOKIE);
             context.commit('setScopedStorageKey', getPendoCookieKey(context.state.storageKey));
+            var scopedThrottlingStorageKeys = {};
+            _.each(THROTTLING_STATE, function (throttlingStorageKey) {
+                scopedThrottlingStorageKeys[throttlingStorageKey] = getPendoCookieKey(throttlingStorageKey);
+            });
+            context.commit('setScopedThrottlingStorageKeys', scopedThrottlingStorageKeys);
             Events.identify.on(function (evt) {
                 if (wasSessionCleared(evt)) {
                     removeIdentificationCookies([LAST_STEP_ADVANCED_COOKIE]);
@@ -20157,11 +20163,21 @@ var GuideStateModule = (function () {
                     });
                 }
             }
+            context.dispatch('loadThrottling');
+        },
+        loadThrottling(context) {
+            const storage = context.getters.storage();
             _.each(THROTTLING_STATE, function (throttlingStorageKey) {
                 const value = storage.read(throttlingStorageKey);
                 context.dispatch('updateThrottlingState', { name: throttlingStorageKey, value });
             });
         },
+        applyThrottling(context) {
+            _.each(THROTTLING_STATE, function (throttlingStorageKey) {
+                pendo$1[throttlingStorageKey] = applyTimerCache(pendo$1[throttlingStorageKey], context.state[throttlingStorageKey]);
+                context.dispatch('updateThrottlingState', { name: throttlingStorageKey, value: pendo$1[throttlingStorageKey] });
+            });
+        },
         forceExpire(context) {
             _.each(context.state.steps, function (stepState, stepId) {
                 context.commit('expireStepState', stepId);
@@ -20237,10 +20253,7 @@ var GuideStateModule = (function () {
             if (mostRecentLastGuideStepSeen) {
                 context.dispatch('updateLastGuideStepSeen', _.extend({}, context.state.lastGuideStepSeen, mostRecentLastGuideStepSeen));
             }
-            _.each(THROTTLING_STATE, function (throttlingStorageKey) {
-                pendo$1[throttlingStorageKey] = applyTimerCache(pendo$1[throttlingStorageKey], context.state[throttlingStorageKey]);
-                context.dispatch('updateThrottlingState', { name: throttlingStorageKey, value: pendo$1[throttlingStorageKey] });
-            });
+            context.dispatch('applyThrottling');
         },
         receiveLastGuideStepSeen(context, lastGuideStepSeen) {
             context.commit('setReceivedLastGuideStepSeen', lastGuideStepSeen);
@@ -20303,6 +20316,10 @@ var GuideStateModule = (function () {
                     }
                 }
             }
+            else if (_.contains(_.values(context.state.scopedThrottlingStorageKeys), storageEvent.key)) {
+                context.dispatch('loadThrottling');
+                context.dispatch('applyThrottling');
+            }
         },
         regainFocus(context) {
             var tabLostFocus = context.getters.tabLostFocus();
@@ -20330,6 +20347,9 @@ var GuideStateModule = (function () {
         setScopedStorageKey(state, scopedStorageKey) {
             state.scopedStorageKey = scopedStorageKey;
         },
+        setScopedThrottlingStorageKeys(state, scopedThrottlingStorageKeys) {
+            state.scopedThrottlingStorageKeys = scopedThrottlingStorageKeys;
+        },
         setLastGuideStepSeen(state, lastGuideStepSeen) {
             state.lastGuideStepSeen = lastGuideStepSeen;
         },
@@ -23570,13 +23590,13 @@ var onGuideDismissed = function (evt, step) {
     var seenReason = firstStep && firstStep.seenReason;
     var language = currentGuide && currentGuide.language;
     var dismissCount = _.get(step, 'dismissCount', 0) + 1;
-    dismissedGuide(guideId, stepId, get_visitor_id(), seenReason, language, dismissCount);
     var now = getNow();
-    _updateGuideStepStatus(guideId, stepId, 'dismissed', now, dismissCount);
-    // maintain latestDismissedAutoAt client-side
+    // maintain latestDismissedAutoAt client-side before guideDismissed writes lastStepAdvanced
     if (shouldAffectThrottling(currentGuide, seenReason)) {
         writeThrottlingStateCache(now, THROTTLING_STATE.DISMISSED);
     }
+    dismissedGuide(guideId, stepId, get_visitor_id(), seenReason, language, dismissCount);
+    _updateGuideStepStatus(guideId, stepId, 'dismissed', now, dismissCount);
     step.hide();
     if (!isGuideShown()) {
         stopGuides();
@@ -23632,12 +23652,12 @@ var onGuideSnoozed = function (evt, step, snoozeDuration) {
     log.info('snoozing guide for ' + snoozeDuration + ' ms');
     var snoozeEndTime = now + snoozeDuration;
     step.snoozeEndTime = snoozeEndTime;
-    snoozedGuide(guideId, stepId, visitorId, seenReason, language, snoozeDuration);
-    _updateGuideStepStatus(guideId, stepId, 'snoozed', now);
-    // maintain latestSnoozedAutoAt client-side
+    // maintain latestSnoozedAutoAt client-side before guideSnoozed writes lastStepAdvanced
     if (shouldAffectThrottling(guide, seenReason)) {
         writeThrottlingStateCache(now, THROTTLING_STATE.SNOOZED);
     }
+    snoozedGuide(guideId, stepId, visitorId, seenReason, language, snoozeDuration);
+    _updateGuideStepStatus(guideId, stepId, 'snoozed', now);
     step.hide();
     if (!isGuideShown()) {
         stopGuides();
@@ -23786,15 +23806,15 @@ var onGuideAdvanced = function (evt, step, isIntermediateStep) {
     if (currentGuide && _.last(currentGuide.steps).id === stepId) {
         dismissCount = _.get(step, 'dismissCount', 0) + 1;
     }
-    log.info('advancing guide');
-    advancedGuide(guideId, stepId, get_visitor_id(), seenReason, language, isIntermediateStep, destinationStepId, dismissCount);
-    log.info('update guide status');
     var now = new Date().getTime();
-    _updateGuideStepStatus(guideId, stepId, 'advanced', now, dismissCount, destinationStepId);
-    // maintain finalAdvancedAutoAt client-side
+    // maintain finalAdvancedAutoAt client-side before guideAdvanced writes lastStepAdvanced
     if (shouldAffectThrottling(currentGuide, seenReason)) {
         writeThrottlingStateCache(now, THROTTLING_STATE.ADVANCED);
     }
+    log.info('advancing guide');
+    advancedGuide(guideId, stepId, get_visitor_id(), seenReason, language, isIntermediateStep, destinationStepId, dismissCount);
+    log.info('update guide status');
+    _updateGuideStepStatus(guideId, stepId, 'advanced', now, dismissCount, destinationStepId);
     log.info('stop guide');
     stopGuides();
     log.info('start guides');
@@ -26035,7 +26055,7 @@ function getWhiteLabelSettings(config) {
     var whiteLabelSettings = ConfigReader.get('whiteLabelSettings');
     if (!whiteLabelSettings && config && config.ux === 'novus') {
         whiteLabelSettings = {
-            logoUrl: 'https://novus.pendo.io/novus-square-icon.svg',
+            logoUrl: 'https://novus.pendo.io/branding/novus-vector-white.svg',
             logoStyle: {
                 maxWidth: '40px',
                 maxHeight: '40px'
@@ -28505,6 +28525,7 @@ const PluginAPI = {
         trim,
         base64EncodeString,
         parseUrl,
+        testPageRule,
         addInlineStyles: _.partial(addInlineStyles, ConfigReader),
         getNow,
         escapeRegExp
@@ -40248,364 +40269,6 @@ class DOMPrompt {
     }
 }
 
-const ASSISTANT_MESSAGE = 'assistantMessage';
-const CONVERSATION_ID_URL_PATTERN = 'conversationIdUrlPattern';
-const MESSAGE_ID_ATTR = 'messageIdAttr';
-const MODEL_USED_ATTR = 'modelUsedAttr';
-const REACTION_ACTIVE = 'reactionActive';
-const STREAMING_ACTIVE = 'streamingActive';
-const STREAMING_ACTIVE_ATTR = 'streamingActiveAttr';
-const THUMB_DOWN = 'thumbDown';
-const THUMB_UP = 'thumbUp';
-const TURN_CONTAINER = 'turnContainer';
-const TURN_ATTR = 'turnAttr';
-const USER_MESSAGE = 'userMessage';
-const CUSTOM_AGENT_ID_URL_PATTERN = 'customAgentIdUrlPattern';
-const CUSTOM_AGENT_NAME = 'customAgentName';
-const REQUIRED_SELECTORS = [
-    ASSISTANT_MESSAGE,
-    CONVERSATION_ID_URL_PATTERN,
-    MESSAGE_ID_ATTR,
-    STREAMING_ACTIVE,
-    TURN_CONTAINER,
-    TURN_ATTR,
-    USER_MESSAGE
-];
-const STREAMING_END_SETTLE_MS = 500;
-const SUBMISSION_START_RETRY_MS = 1000;
-const SUBMISSION_START_MAX_ATTEMPTS = 4;
-class DOMConversation {
-    // Returns the list of required selector types that are missing or empty
-    // in the given cssSelectors config. An empty array means the config is
-    // valid for instantiation.
-    static validateConfig(cssSelectors) {
-        if (!Array.isArray(cssSelectors)) {
-            return REQUIRED_SELECTORS.slice();
-        }
-        const present = new Set();
-        for (const cfg of cssSelectors) {
-            if (!cfg || !cfg.type || !cfg.cssSelector)
-                continue;
-            if (cfg.type === CONVERSATION_ID_URL_PATTERN) {
-                try {
-                    RegExp(cfg.cssSelector);
-                }
-                catch (e) {
-                    continue;
-                }
-            }
-            present.add(cfg.type);
-        }
-        return REQUIRED_SELECTORS.filter((r) => !present.has(r));
-    }
-    static supportedPreset(preset) {
-        return preset === 'chatgpt-full';
-    }
-    constructor(pendo, PluginAPI, id, privacyFilters, cssSelectors) {
-        this.selectors = {};
-        this.listeners = [];
-        this.isActive = true;
-        this.observers = [];
-        this.wasStreaming = false;
-        this.streamingEndTimer = null;
-        this.submissionStartRetryTimer = null;
-        this.requestNode = null;
-        this.conversationIdRegex = null;
-        this.customAgentIdRegex = null;
-        this.lastReturnedMessageId = null;
-        this.dom = pendo.dom;
-        this._ = pendo._;
-        this.api = PluginAPI;
-        this.Sizzle = pendo.Sizzle;
-        this.id = id;
-        this.setFilters(privacyFilters);
-        if (!this._.isArray(cssSelectors)) {
-            this.api.log.error(`cssSelectors must be an array, received: ${typeof cssSelectors}`);
-            cssSelectors = [];
-        }
-        this._.each(cssSelectors, (cfg) => {
-            if (cfg && cfg.type) {
-                this.selectors[cfg.type] = cfg.cssSelector;
-            }
-        });
-        this.conversationIdRegex = new RegExp(this.selectors[CONVERSATION_ID_URL_PATTERN]);
-        const customAgentIdUrlPattern = this.selectors[CUSTOM_AGENT_ID_URL_PATTERN];
-        if (customAgentIdUrlPattern) { // this is optional
-            try {
-                this.customAgentIdRegex = new RegExp(customAgentIdUrlPattern);
-            }
-            catch (error) {
-                this.api.log.error(`bad customAgentIdUrlPattern ${customAgentIdUrlPattern}`, { error });
-            }
-        }
-        this.root = document.body;
-        this.setupReactionListener();
-        this.setupStreamingObserver();
-    }
-    setupReactionListener() {
-        if (!this.findSelector(THUMB_UP) && !this.findSelector(THUMB_DOWN))
-            return;
-        this.reactionClickHandler = this.handleReactionClick.bind(this);
-        this.root.addEventListener('click', this.reactionClickHandler, true);
-    }
-    handleReactionClick(evt) {
-        const target = evt.target;
-        if (!target || target.nodeType !== 1)
-            return;
-        const upSelector = this.findSelector(THUMB_UP);
-        const downSelector = this.findSelector(THUMB_DOWN);
-        const thumb = this.dom(target).closest(`${upSelector}, ${downSelector}`);
-        if (!thumb.length)
-            return;
-        const isUp = this.Sizzle.matchesSelector(thumb[0], upSelector);
-        const activeSelector = this.findSelector(REACTION_ACTIVE);
-        const wasPressed = activeSelector && this.Sizzle.matchesSelector(thumb[0], activeSelector);
-        const direction = isUp ? 'positive' : 'negative';
-        const content = wasPressed ? 'unreact' : direction;
-        const assistantNode = thumb.closest(this.findSelector(TURN_CONTAINER))
-            .find(this.findSelector(ASSISTANT_MESSAGE));
-        this.emit('user_reaction', {
-            agentId: this.id,
-            messageId: this.getMessageId(assistantNode),
-            content,
-            privacyFilterApplied: false
-        });
-    }
-    // observe the streaming indicator
-    setupStreamingObserver() {
-        this.wasStreaming = this.select(STREAMING_ACTIVE).length > 0;
-        this.stopStreamingEndTimer();
-        const MutationObserver = getZoneSafeMethod('MutationObserver');
-        const observer = new MutationObserver(this.handleMutation.bind(this));
-        const attrName = this.findSelector(STREAMING_ACTIVE_ATTR);
-        observer.observe(this.root, {
-            childList: true,
-            subtree: true,
-            attributes: true,
-            attributeFilter: attrName ? [attrName] : undefined
-        });
-        this.observers.push(observer);
-    }
-    // look for changes in the state of the streaming indicator.
-    // streaming started -> a prompt has been submitted
-    // streaming ended -> got a response
-    // we don't send the prompt immediately when it's submitted because it might not have a
-    // conversation id yet.
-    // we don't send the agent_response immediately when the streaming indicator is cleared
-    // because it clears slightly before the final text chunk is committed to the DOM so the
-    // end-handling is deferred by a short settle window
-    handleMutation() {
-        const isStreaming = this.select(STREAMING_ACTIVE).length > 0;
-        if (isStreaming === this.wasStreaming)
-            return;
-        if (isStreaming) { // started streaming
-            if (!this.streamingEndTimer) {
-                this.onSubmissionStart();
-            }
-            else {
-                // stream restarted during the settle window (multi-phase response).
-                // treat as a continuation of the prior request, not a new submission.
-                // we'll handle it next time streaming stops
-                this.stopStreamingEndTimer();
-            }
-        }
-        else { // finished streaming
-            this.startStreamingEndTimer();
-        }
-        this.wasStreaming = isStreaming;
-    }
-    onSubmissionStart(attempt = 1) {
-        this.requestNode = this.findLastRequestNode();
-        if (this.requestNode) {
-            this.handleUserMessage(this.requestNode);
-            return;
-        }
-        // URL hasn't flipped yet to include the conversation id on a fresh chat
-        // retry, if that still fails, onSubmissionEnd handles it
-        if (attempt < SUBMISSION_START_MAX_ATTEMPTS) {
-            this.startSubmissionStartRetryTimer(attempt + 1);
-        }
-    }
-    onSubmissionEnd() {
-        this.stopSubmissionStartRetryTimer();
-        let requestNode = this.requestNode;
-        this.requestNode = null;
-        if (!requestNode) {
-            // onSubmissionStart didn't send, send it now
-            requestNode = this.findLastRequestNode();
-            if (!requestNode)
-                return;
-            this.handleUserMessage(requestNode);
-        }
-        const requestTurn = this.findTurnNumber(requestNode);
-        if (requestTurn === null)
-            return;
-        const assistantNodes = this.select(ASSISTANT_MESSAGE);
-        const toEmit = [];
-        for (let i = assistantNodes.length - 1; i >= 0; i--) {
-            const n = this.findTurnNumber(this.dom(assistantNodes[i]));
-            if (n === null)
-                continue;
-            if (n <= requestTurn)
-                break;
-            toEmit.push(assistantNodes[i]);
-        }
-        // emit in chronological order (reverse of collection order)
-        for (let i = toEmit.length - 1; i >= 0; i--) {
-            this.handleAssistantMessage(this.dom(toEmit[i]));
-        }
-    }
-    extractContent(node) {
-        const rawContent = node.text().trim();
-        const content = this.applyPrivacyFilter(rawContent);
-        return { content, privacyFilterApplied: content !== rawContent };
-    }
-    getMessageId(node) {
-        return node.attr(this.findSelector(MESSAGE_ID_ATTR));
-    }
-    handleUserMessage(node) {
-        this.emit('prompt', Object.assign({ agentId: this.id, messageId: this.getMessageId(node) }, this.extractContent(node)));
-    }
-    handleAssistantMessage(node) {
-        const modelUsedAttr = this.findSelector(MODEL_USED_ATTR);
-        const modelUsed = modelUsedAttr && node.attr(modelUsedAttr);
-        this.emit('agent_response', Object.assign({ agentId: this.id, messageId: this.getMessageId(node), agentModelsUsed: modelUsed ? [modelUsed] : [] }, this.extractContent(node)));
-    }
-    findLastRequestNode() {
-        if (!this.getConversationId())
-            return null;
-        const node = this._.last(this.select(USER_MESSAGE));
-        if (!node)
-            return null;
-        const $node = this.dom(node);
-        const messageId = this.getMessageId($node);
-        if (!messageId)
-            return null;
-        if (messageId === this.lastReturnedMessageId)
-            return null;
-        this.lastReturnedMessageId = messageId;
-        return $node;
-    }
-    findTurnNumber(node) {
-        const turnSelector = this.findSelector(TURN_CONTAINER);
-        const turnAttr = this.findSelector(TURN_ATTR);
-        const turn = node.closest(turnSelector).attr(turnAttr);
-        if (!turn)
-            return null;
-        const seqMatch = String(turn).match(/\d+/);
-        return seqMatch ? parseInt(seqMatch[0], 10) : null;
-    }
-    findSelector(type) {
-        return this.selectors[type];
-    }
-    select(type) {
-        return this.dom(this.findSelector(type), this.root);
-    }
-    getConversationId() {
-        const m = location.href.match(this.conversationIdRegex);
-        if (!m)
-            return null;
-        return m[1] !== undefined ? m[1] : m[0];
-    }
-    getCustomAgentId() {
-        if (!this.customAgentIdRegex)
-            return undefined;
-        const m = location.href.match(this.customAgentIdRegex);
-        if (!m)
-            return undefined;
-        return m[1] !== undefined ? m[1] : m[0];
-    }
-    getCustomAgentName() {
-        if (!this.findSelector(CUSTOM_AGENT_NAME))
-            return '';
-        const node = this.select(CUSTOM_AGENT_NAME);
-        if (!node.length)
-            return '';
-        return node.text().trim();
-    }
-    addCustomAgentInfo(eventPayload) {
-        const customAgentId = this.getCustomAgentId();
-        if (!customAgentId)
-            return;
-        eventPayload.customAgentId = customAgentId;
-        const customAgentName = this.getCustomAgentName();
-        if (customAgentName) {
-            eventPayload.customAgentName = customAgentName;
-        }
-    }
-    setFilters(candidateFilter) {
-        if (!candidateFilter) {
-            this.privacyFilters = null;
-            return null;
-        }
-        try {
-            this.privacyFilters = new RegExp(candidateFilter, 'gmi');
-        }
-        catch (e) {
-            this.privacyFilters = null;
-            this.api.log.error(e);
-        }
-        return this.privacyFilters;
-    }
-    applyPrivacyFilter(candidateValue, filters = null) {
-        const filtersToUse = filters || this.privacyFilters;
-        if (!filtersToUse || !this._.isRegExp(filtersToUse))
-            return candidateValue;
-        return candidateValue.replace(filtersToUse, 'redacted');
-    }
-    onSubmit(callback) {
-        this.listeners.push(callback);
-    }
-    emit(eventType, eventPayload) {
-        eventPayload.conversationId = this.getConversationId();
-        this.addCustomAgentInfo(eventPayload);
-        this._.each(this.listeners, (cb) => cb(eventType, eventPayload));
-    }
-    startStreamingEndTimer() {
-        this.stopStreamingEndTimer();
-        this.streamingEndTimer = setTimeout$1(() => {
-            this.streamingEndTimer = null;
-            this.onSubmissionEnd();
-        }, STREAMING_END_SETTLE_MS);
-    }
-    stopStreamingEndTimer() {
-        if (!this.streamingEndTimer)
-            return;
-        clearTimeout(this.streamingEndTimer);
-        this.streamingEndTimer = null;
-    }
-    startSubmissionStartRetryTimer(attempt) {
-        this.stopSubmissionStartRetryTimer();
-        this.submissionStartRetryTimer = setTimeout$1(() => {
-            this.submissionStartRetryTimer = null;
-            this.onSubmissionStart(attempt);
-        }, SUBMISSION_START_RETRY_MS);
-    }
-    stopSubmissionStartRetryTimer() {
-        if (!this.submissionStartRetryTimer)
-            return;
-        clearTimeout(this.submissionStartRetryTimer);
-        this.submissionStartRetryTimer = null;
-    }
-    suspend() {
-        this.isActive = false;
-    }
-    resume() {
-        this.isActive = true;
-    }
-    teardown() {
-        this._.each(this.observers, (o) => o && o.disconnect && o.disconnect());
-        this.observers = [];
-        if (this.reactionClickHandler && this.root) {
-            this.root.removeEventListener('click', this.reactionClickHandler, true);
-            this.reactionClickHandler = null;
-        }
-        this.stopStreamingEndTimer();
-        this.stopSubmissionStartRetryTimer();
-        this.listeners = [];
-    }
-}
-
 /*
  * Prompt Analytics Plugin
  *
@@ -40690,6 +40353,9 @@ class PromptPlugin {
         });
         const currentlyActiveIds = this._.map(this._.filter(this.prompts, prompt => prompt.isActive), prompt => prompt.id);
         this._.each(allAgents, aiAgent => {
+            if (this.isConversationAgent(aiAgent)) {
+                return;
+            }
             const isCurrentlyActive = this._.contains(currentlyActiveIds, aiAgent.id);
             const shouldBeActive = this.testPageRule(aiAgent.pageRule, currentUrl, aiAgent.id);
             if (shouldBeActive && !isCurrentlyActive) {
@@ -40708,6 +40374,10 @@ class PromptPlugin {
             return candidateValue;
         return candidateValue.replace(filters, 'redacted');
     }
+    // conversation agents, owned by the ConversationAnalytics plugin.
+    isConversationAgent(agent) {
+        return agent.preset && agent.preset != 'chatgpt';
+    }
     onConfigLoaded(aiAgents = []) {
         if (!aiAgents || !this._.isArray(aiAgents) || aiAgents.length === 0) {
             return;
@@ -40715,6 +40385,9 @@ class PromptPlugin {
         const networkAgents = [];
         const domAgents = [];
         for (const agent of aiAgents) {
+            if (this.isConversationAgent(agent)) {
+                continue;
+            }
             if (agent.trackingMethod === 'network') {
                 networkAgents.push(agent);
             }
@@ -40770,25 +40443,12 @@ class PromptPlugin {
         }
     }
     observePrompt(config) {
-        const { id, cssSelectors, privacyFilters, preset } = config;
+        const { id, cssSelectors, privacyFilters } = config;
         // Check if agent already exists
         const existingPrompt = this._.find(this.prompts, prompt => prompt.id === id);
         if (existingPrompt) {
             return;
         }
-        if (DOMConversation.supportedPreset(preset)) {
-            const missing = DOMConversation.validateConfig(cssSelectors);
-            if (missing.length) {
-                this.api.log.error('aiAgent config missing required selectors', { agentId: id, missing });
-                return;
-            }
-            const conversation = new DOMConversation(this.pendo, this.api, id, privacyFilters, cssSelectors);
-            conversation.onSubmit((eventType, payload) => {
-                this.sendConversationEvent(eventType, payload);
-            });
-            this.prompts.push(conversation);
-            return;
-        }
         let inputCssSelectors, submitCssSelectors;
         inputCssSelectors = this.parseCssSelector('input', cssSelectors);
         submitCssSelectors = this.parseCssSelector('submit', cssSelectors);
@@ -40815,15 +40475,6 @@ class PromptPlugin {
         }, promptEvent);
         this.api.analytics.collectEvent('prompt', event, undefined, 'agentic');
     }
-    sendConversationEvent(eventType, eventPayload) {
-        // Block event if the prompt is suspended
-        const conv = this._.find(this.prompts, p => p.id === eventPayload.agentId);
-        if (conv && !conv.isActive) {
-            return;
-        }
-        eventPayload = this._.extend({ agentType: 'conversation' }, eventPayload);
-        this.api.analytics.collectEvent(eventType, eventPayload, undefined, 'agentic');
-    }
     teardown() {
         this._.each(this.prompts, (prompt) => prompt.teardown());
         if (this.agentsCache) {
@@ -41210,10 +40861,7 @@ class WebAnalytics {
             PluginAPI.attachEvent(PluginAPI.Events, 'eventCaptured', bind(this.addUtmToEvent, this)),
             PluginAPI.attachEvent(PluginAPI.Events, 'sessionChanged', bind(this.sessionChanged, this))
         ];
-        let params = this.loadParameters(PluginAPI.agentStorage);
-        if (!params || pendo._.isEmpty(params)) {
-            params = this.extractParameters(window.location.href, document.referrer);
-        }
+        this.suffix = this.api.ConfigReader.get('identityStorageSuffix');
         /**
          * Stores UTM parameters that were present in the URL when the visitor loaded the application.
          *
@@ -41222,9 +40870,12 @@ class WebAnalytics {
          * @access public
          * @label WEB_ANALYTICS_STORAGE_KEY
          */
-        this.api.agentStorage.registry.addLocal(WEB_ANALYTICS_STORAGE_KEY);
+        this.api.agentStorage.registry.addLocal(WEB_ANALYTICS_STORAGE_KEY, { cookieSuffix: this.suffix, isSecure: true });
+        let params = this.loadParameters(PluginAPI.agentStorage);
+        if (!params || pendo._.isEmpty(params)) {
+            params = this.extractParameters(window.location.href, document.referrer);
+        }
         this.storeParameters(params, PluginAPI.agentStorage);
-        this.suffix = this.api.ConfigReader.get('identityStorageSuffix');
     }
     extractParameters(url, referrer) {
         const locationUrl = new URL(url);
@@ -41279,12 +40930,12 @@ class WebAnalytics {
     }
     storeParameters(params, storage) {
         if (this.pendo._.size(params) > 0) {
-            storage.write(WEB_ANALYTICS_STORAGE_KEY, JSON.stringify(params), undefined, false, true, this.suffix);
+            storage.write(WEB_ANALYTICS_STORAGE_KEY, JSON.stringify(params));
         }
     }
     loadParameters(storage) {
-        const storedParamsJson = storage.read(WEB_ANALYTICS_STORAGE_KEY, false, this.suffix) ||
-            storage.read(WEB_ANALYTICS_STORAGE_KEY);
+        const storedParamsJson = storage.read(WEB_ANALYTICS_STORAGE_KEY) ||
+            storage.read(WEB_ANALYTICS_STORAGE_KEY, false, '');
         if (storedParamsJson)
             return JSON.parse(storedParamsJson);
         return null;
@@ -41310,7 +40961,7 @@ class WebAnalytics {
     sessionChanged() {
         const agentStorage = this.api.agentStorage;
         agentStorage.clear(WEB_ANALYTICS_STORAGE_KEY);
-        agentStorage.clear(WEB_ANALYTICS_STORAGE_KEY, false, this.suffix);
+        agentStorage.clear(WEB_ANALYTICS_STORAGE_KEY, false, '');
         const params = this.extractParameters(window.location.href, document.referrer);
         this.storeParameters(params, agentStorage);
     }
@@ -41805,6 +41456,21 @@ function branchingGoToStep(event, step, guide, pendo) {
     event.cancel = true;
 }
 
+var DANGEROUS_URL_SCHEME = /^\s*(javascript|data|vbscript):/i;
+function encodeMetadataForUrl(value, urlBeforePlaceholder) {
+    if (urlBeforePlaceholder === void 0) { urlBeforePlaceholder = ''; }
+    var str = value === undefined || value === null ? '' : String(value);
+    var inUrlComponent = urlBeforePlaceholder.indexOf('?') !== -1 || urlBeforePlaceholder.indexOf('#') !== -1;
+    if (inUrlComponent) {
+        return window.encodeURIComponent(str);
+    }
+    var schemeAlreadySet = urlBeforePlaceholder.indexOf(':') !== -1;
+    if (!schemeAlreadySet && DANGEROUS_URL_SCHEME.test(str)) {
+        return '';
+    }
+    return window.encodeURI(str);
+}
+
 const MetadataSubstitution = {
     name: 'MetadataSubstitution',
     script(step, guide, pendo) {
@@ -41948,8 +41614,10 @@ function substituteMetadataByTarget(data, target, mdValue, matched) {
         ? (data.getAttribute(target) || '')
         : data[target];
     if (target === 'href' || target === 'value') {
-        const safeValue = window.encodeURIComponent(String(mdValue === undefined || mdValue === null ? '' : mdValue));
-        data[target] = decodeURI(current).replace(matched[0], safeValue);
+        const decodedUrl = decodeURI(current);
+        const urlBeforePlaceholder = decodedUrl.slice(0, decodedUrl.indexOf(matched[0]));
+        const safeValue = encodeMetadataForUrl(mdValue, urlBeforePlaceholder);
+        data[target] = decodedUrl.replace(matched[0], safeValue);
     }
     else {
         data[target] = current.replace(matched[0], mdValue);
@@ -53384,4 +53052,500 @@ const PredictGuides = () => {
     };
 };
 
-export { ConsoleCapture, Feedback, GuideMarkdown, NetworkCapture, PredictGuides, createReplayPlugin as Replay, TextCapture, VocPortal, loadAgent };
+const ASSISTANT_MESSAGE = 'assistantMessage';
+const CONVERSATION_ID_URL_PATTERN = 'conversationIdUrlPattern';
+const MESSAGE_ID_ATTR = 'messageIdAttr';
+const MODEL_USED_ATTR = 'modelUsedAttr';
+const REACTION_ACTIVE = 'reactionActive';
+const STREAMING_ACTIVE = 'streamingActive';
+const STREAMING_ACTIVE_ATTR = 'streamingActiveAttr';
+const THUMB_DOWN = 'thumbDown';
+const THUMB_UP = 'thumbUp';
+const TURN_CONTAINER = 'turnContainer';
+const TURN_ATTR = 'turnAttr';
+const USER_MESSAGE = 'userMessage';
+const CUSTOM_AGENT_ID_URL_PATTERN = 'customAgentIdUrlPattern';
+const CUSTOM_AGENT_NAME = 'customAgentName';
+const REQUIRED_SELECTORS = [
+    ASSISTANT_MESSAGE,
+    CONVERSATION_ID_URL_PATTERN,
+    MESSAGE_ID_ATTR,
+    STREAMING_ACTIVE,
+    TURN_CONTAINER,
+    TURN_ATTR,
+    USER_MESSAGE
+];
+const STREAMING_END_SETTLE_MS = 500;
+const SUBMISSION_START_RETRY_MS = 1000;
+const SUBMISSION_START_MAX_ATTEMPTS = 4;
+class DOMConversation {
+    // Returns the list of required selector types that are missing or empty
+    // in the given cssSelectors config. An empty array means the config is
+    // valid for instantiation.
+    static validateConfig(cssSelectors) {
+        if (!Array.isArray(cssSelectors)) {
+            return REQUIRED_SELECTORS.slice();
+        }
+        const present = new Set();
+        for (const cfg of cssSelectors) {
+            if (!cfg || !cfg.type || !cfg.cssSelector)
+                continue;
+            if (cfg.type === CONVERSATION_ID_URL_PATTERN) {
+                try {
+                    RegExp(cfg.cssSelector);
+                }
+                catch (e) {
+                    continue;
+                }
+            }
+            present.add(cfg.type);
+        }
+        return REQUIRED_SELECTORS.filter((r) => !present.has(r));
+    }
+    static supportedPreset(preset) {
+        return preset === 'chatgpt-full';
+    }
+    constructor(pendo, PluginAPI, id, privacyFilters, cssSelectors) {
+        this.selectors = {};
+        this.listeners = [];
+        this.isActive = true;
+        this.observers = [];
+        this.wasStreaming = false;
+        this.streamingEndTimer = null;
+        this.submissionStartRetryTimer = null;
+        this.requestNode = null;
+        this.conversationIdRegex = null;
+        this.customAgentIdRegex = null;
+        this.lastReturnedMessageId = null;
+        this.dom = pendo.dom;
+        this._ = pendo._;
+        this.api = PluginAPI;
+        this.Sizzle = pendo.Sizzle;
+        this.id = id;
+        this.setFilters(privacyFilters);
+        if (!this._.isArray(cssSelectors)) {
+            this.api.log.error(`cssSelectors must be an array, received: ${typeof cssSelectors}`);
+            cssSelectors = [];
+        }
+        this._.each(cssSelectors, (cfg) => {
+            if (cfg && cfg.type) {
+                this.selectors[cfg.type] = cfg.cssSelector;
+            }
+        });
+        this.conversationIdRegex = new RegExp(this.selectors[CONVERSATION_ID_URL_PATTERN]);
+        const customAgentIdUrlPattern = this.selectors[CUSTOM_AGENT_ID_URL_PATTERN];
+        if (customAgentIdUrlPattern) { // this is optional
+            try {
+                this.customAgentIdRegex = new RegExp(customAgentIdUrlPattern);
+            }
+            catch (error) {
+                this.api.log.error(`bad customAgentIdUrlPattern ${customAgentIdUrlPattern}`, { error });
+            }
+        }
+        this.root = document.body;
+        this.setupReactionListener();
+        this.setupStreamingObserver();
+    }
+    setupReactionListener() {
+        if (!this.findSelector(THUMB_UP) && !this.findSelector(THUMB_DOWN))
+            return;
+        this.reactionClickHandler = this.handleReactionClick.bind(this);
+        this.root.addEventListener('click', this.reactionClickHandler, true);
+    }
+    handleReactionClick(evt) {
+        const target = evt.target;
+        if (!target || target.nodeType !== 1)
+            return;
+        const upSelector = this.findSelector(THUMB_UP);
+        const downSelector = this.findSelector(THUMB_DOWN);
+        const thumb = this.dom(target).closest(`${upSelector}, ${downSelector}`);
+        if (!thumb.length)
+            return;
+        const isUp = this.Sizzle.matchesSelector(thumb[0], upSelector);
+        const activeSelector = this.findSelector(REACTION_ACTIVE);
+        const wasPressed = activeSelector && this.Sizzle.matchesSelector(thumb[0], activeSelector);
+        const direction = isUp ? 'positive' : 'negative';
+        const content = wasPressed ? 'unreact' : direction;
+        const assistantNode = thumb.closest(this.findSelector(TURN_CONTAINER))
+            .find(this.findSelector(ASSISTANT_MESSAGE));
+        this.emit('user_reaction', {
+            agentId: this.id,
+            messageId: this.getMessageId(assistantNode),
+            content,
+            privacyFilterApplied: false
+        });
+    }
+    // observe the streaming indicator
+    setupStreamingObserver() {
+        this.wasStreaming = this.select(STREAMING_ACTIVE).length > 0;
+        this.stopStreamingEndTimer();
+        const MutationObserver = getZoneSafeMethod(this._, 'MutationObserver');
+        const observer = new MutationObserver(this.handleMutation.bind(this));
+        const attrName = this.findSelector(STREAMING_ACTIVE_ATTR);
+        observer.observe(this.root, {
+            childList: true,
+            subtree: true,
+            attributes: true,
+            attributeFilter: attrName ? [attrName] : undefined
+        });
+        this.observers.push(observer);
+    }
+    // look for changes in the state of the streaming indicator.
+    // streaming started -> a prompt has been submitted
+    // streaming ended -> got a response
+    // we don't send the prompt immediately when it's submitted because it might not have a
+    // conversation id yet.
+    // we don't send the agent_response immediately when the streaming indicator is cleared
+    // because it clears slightly before the final text chunk is committed to the DOM so the
+    // end-handling is deferred by a short settle window
+    handleMutation() {
+        const isStreaming = this.select(STREAMING_ACTIVE).length > 0;
+        if (isStreaming === this.wasStreaming)
+            return;
+        if (isStreaming) { // started streaming
+            if (!this.streamingEndTimer) {
+                this.onSubmissionStart();
+            }
+            else {
+                // stream restarted during the settle window (multi-phase response).
+                // treat as a continuation of the prior request, not a new submission.
+                // we'll handle it next time streaming stops
+                this.stopStreamingEndTimer();
+            }
+        }
+        else { // finished streaming
+            this.startStreamingEndTimer();
+        }
+        this.wasStreaming = isStreaming;
+    }
+    onSubmissionStart(attempt = 1) {
+        this.requestNode = this.findLastRequestNode();
+        if (this.requestNode) {
+            this.handleUserMessage(this.requestNode);
+            return;
+        }
+        // URL hasn't flipped yet to include the conversation id on a fresh chat
+        // retry, if that still fails, onSubmissionEnd handles it
+        if (attempt < SUBMISSION_START_MAX_ATTEMPTS) {
+            this.startSubmissionStartRetryTimer(attempt + 1);
+        }
+    }
+    onSubmissionEnd() {
+        this.stopSubmissionStartRetryTimer();
+        let requestNode = this.requestNode;
+        this.requestNode = null;
+        if (!requestNode) {
+            // onSubmissionStart didn't send, send it now
+            requestNode = this.findLastRequestNode();
+            if (!requestNode)
+                return;
+            this.handleUserMessage(requestNode);
+        }
+        const requestTurn = this.findTurnNumber(requestNode);
+        if (requestTurn === null)
+            return;
+        const assistantNodes = this.select(ASSISTANT_MESSAGE);
+        const toEmit = [];
+        for (let i = assistantNodes.length - 1; i >= 0; i--) {
+            const n = this.findTurnNumber(this.dom(assistantNodes[i]));
+            if (n === null)
+                continue;
+            if (n <= requestTurn)
+                break;
+            toEmit.push(assistantNodes[i]);
+        }
+        // emit in chronological order (reverse of collection order)
+        for (let i = toEmit.length - 1; i >= 0; i--) {
+            this.handleAssistantMessage(this.dom(toEmit[i]));
+        }
+    }
+    extractContent(node) {
+        const rawContent = node.text().trim();
+        const content = this.applyPrivacyFilter(rawContent);
+        return { content, privacyFilterApplied: content !== rawContent };
+    }
+    getMessageId(node) {
+        return node.attr(this.findSelector(MESSAGE_ID_ATTR));
+    }
+    handleUserMessage(node) {
+        this.emit('prompt', Object.assign({ agentId: this.id, messageId: this.getMessageId(node) }, this.extractContent(node)));
+    }
+    handleAssistantMessage(node) {
+        const modelUsedAttr = this.findSelector(MODEL_USED_ATTR);
+        const modelUsed = modelUsedAttr && node.attr(modelUsedAttr);
+        this.emit('agent_response', Object.assign({ agentId: this.id, messageId: this.getMessageId(node), agentModelsUsed: modelUsed ? [modelUsed] : [] }, this.extractContent(node)));
+    }
+    findLastRequestNode() {
+        if (!this.getConversationId())
+            return null;
+        const node = this._.last(this.select(USER_MESSAGE));
+        if (!node)
+            return null;
+        const $node = this.dom(node);
+        const messageId = this.getMessageId($node);
+        if (!messageId)
+            return null;
+        if (messageId === this.lastReturnedMessageId)
+            return null;
+        this.lastReturnedMessageId = messageId;
+        return $node;
+    }
+    findTurnNumber(node) {
+        const turnSelector = this.findSelector(TURN_CONTAINER);
+        const turnAttr = this.findSelector(TURN_ATTR);
+        const turn = node.closest(turnSelector).attr(turnAttr);
+        if (!turn)
+            return null;
+        const seqMatch = String(turn).match(/\d+/);
+        return seqMatch ? parseInt(seqMatch[0], 10) : null;
+    }
+    findSelector(type) {
+        return this.selectors[type];
+    }
+    select(type) {
+        return this.dom(this.findSelector(type), this.root);
+    }
+    getConversationId() {
+        const m = location.href.match(this.conversationIdRegex);
+        if (!m)
+            return null;
+        return m[1] !== undefined ? m[1] : m[0];
+    }
+    getCustomAgentId() {
+        if (!this.customAgentIdRegex)
+            return undefined;
+        const m = location.href.match(this.customAgentIdRegex);
+        if (!m)
+            return undefined;
+        return m[1] !== undefined ? m[1] : m[0];
+    }
+    getCustomAgentName() {
+        if (!this.findSelector(CUSTOM_AGENT_NAME))
+            return '';
+        const node = this.select(CUSTOM_AGENT_NAME);
+        if (!node.length)
+            return '';
+        return node.text().trim();
+    }
+    addCustomAgentInfo(eventPayload) {
+        const customAgentId = this.getCustomAgentId();
+        if (!customAgentId)
+            return;
+        eventPayload.customAgentId = customAgentId;
+        const customAgentName = this.getCustomAgentName();
+        if (customAgentName) {
+            eventPayload.customAgentName = customAgentName;
+        }
+    }
+    setFilters(candidateFilter) {
+        if (!candidateFilter) {
+            this.privacyFilters = null;
+            return null;
+        }
+        try {
+            this.privacyFilters = new RegExp(candidateFilter, 'gmi');
+        }
+        catch (e) {
+            this.privacyFilters = null;
+            this.api.log.error(e);
+        }
+        return this.privacyFilters;
+    }
+    applyPrivacyFilter(candidateValue, filters = null) {
+        const filtersToUse = filters || this.privacyFilters;
+        if (!filtersToUse || !this._.isRegExp(filtersToUse))
+            return candidateValue;
+        return candidateValue.replace(filtersToUse, 'redacted');
+    }
+    onSubmit(callback) {
+        this.listeners.push(callback);
+    }
+    emit(eventType, eventPayload) {
+        eventPayload.conversationId = this.getConversationId();
+        this.addCustomAgentInfo(eventPayload);
+        this._.each(this.listeners, (cb) => cb(eventType, eventPayload));
+    }
+    startStreamingEndTimer() {
+        this.stopStreamingEndTimer();
+        this.streamingEndTimer = setTimeout$1(() => {
+            this.streamingEndTimer = null;
+            this.onSubmissionEnd();
+        }, STREAMING_END_SETTLE_MS);
+    }
+    stopStreamingEndTimer() {
+        if (!this.streamingEndTimer)
+            return;
+        clearTimeout(this.streamingEndTimer);
+        this.streamingEndTimer = null;
+    }
+    startSubmissionStartRetryTimer(attempt) {
+        this.stopSubmissionStartRetryTimer();
+        this.submissionStartRetryTimer = setTimeout$1(() => {
+            this.submissionStartRetryTimer = null;
+            this.onSubmissionStart(attempt);
+        }, SUBMISSION_START_RETRY_MS);
+    }
+    stopSubmissionStartRetryTimer() {
+        if (!this.submissionStartRetryTimer)
+            return;
+        clearTimeout(this.submissionStartRetryTimer);
+        this.submissionStartRetryTimer = null;
+    }
+    suspend() {
+        this.isActive = false;
+    }
+    resume() {
+        this.isActive = true;
+    }
+    teardown() {
+        this._.each(this.observers, (o) => o && o.disconnect && o.disconnect());
+        this.observers = [];
+        if (this.reactionClickHandler && this.root) {
+            this.root.removeEventListener('click', this.reactionClickHandler, true);
+            this.reactionClickHandler = null;
+        }
+        this.stopStreamingEndTimer();
+        this.stopSubmissionStartRetryTimer();
+        this.listeners = [];
+    }
+}
+
+/*
+ * Conversation Analytics Plugin
+ *
+ * Independent plugin that tracks AI-agent conversations rendered in the DOM.
+ *
+ * The sibling built-in PromptAnalytics plugin owns the network + DOMPrompt AI-agents
+ */
+function ConversationAnalytics() {
+    let pendo;
+    let api;
+    let _;
+    let log;
+    let conversations = [];
+    let agentsCache = new Map();
+    const CONFIG_NAME = 'aiAgents';
+    return {
+        name: 'ConversationAnalytics',
+        initialize,
+        teardown,
+        onConfigLoaded,
+        observeConversation,
+        sendConversationEvent,
+        reEvaluatePageRules
+    };
+    function initialize(pendoGlobal, PluginAPI) {
+        var _a;
+        pendo = pendoGlobal;
+        api = PluginAPI;
+        _ = pendo._;
+        log = api.log;
+        const { ConfigReader } = api;
+        ConfigReader.addOption(CONFIG_NAME, [
+            ConfigReader.sources.PENDO_CONFIG_SRC,
+            ConfigReader.sources.SNIPPET_SRC
+        ]);
+        onConfigLoaded(ConfigReader.get(CONFIG_NAME));
+        // Listen for URL changes to re-evaluate page rules
+        // Listening on guidesLoaded since normalizedUrl comes back from the guides playload
+        (_a = api.Events.guidesLoaded) === null || _a === void 0 ? void 0 : _a.on(reEvaluatePageRules);
+    }
+    // Test if the current URL matches the page rule for an agent. The raw matcher lives in core
+    // and is reached through PluginAPI (independent plugins cannot import it directly); it falls
+    // back to the normalized URL internally when no URL is passed.
+    function testPageRule(pageRule, agentId = 'unknown') {
+        // Convert //*/agent pattern to work with full URLs
+        let fixedPageRule = pageRule;
+        if (Array.isArray(pageRule)) {
+            const validRules = _.filter(pageRule, rule => rule && rule.trim() !== '');
+            fixedPageRule = _.map(validRules, rule => rule.startsWith('//*/') ? rule.substring(1) : rule);
+        }
+        else if (typeof pageRule === 'string' && pageRule.startsWith('//*/')) {
+            fixedPageRule = pageRule.substring(1);
+        }
+        return api.util.testPageRule(fixedPageRule, undefined, {
+            logger: log,
+            context: 'agent',
+            id: agentId
+        });
+    }
+    function reEvaluatePageRules() {
+        _.each(conversations, conversation => {
+            const agent = findAgentById(conversation.id);
+            const shouldBeActive = agent && testPageRule(agent.pageRule, agent.id);
+            if (shouldBeActive) {
+                conversation.resume();
+            }
+            else {
+                conversation.suspend();
+            }
+        });
+        const currentlyActiveIds = _.map(_.filter(conversations, conversation => conversation.isActive), conversation => conversation.id);
+        const allAgents = api.ConfigReader.get(CONFIG_NAME) || [];
+        _.each(allAgents, aiAgent => {
+            if (!isConversationAgent(aiAgent)) {
+                return;
+            }
+            const isCurrentlyActive = _.contains(currentlyActiveIds, aiAgent.id);
+            const shouldBeActive = testPageRule(aiAgent.pageRule, aiAgent.id);
+            if (shouldBeActive && !isCurrentlyActive) {
+                observeConversation(aiAgent);
+            }
+        });
+    }
+    function findAgentById(agentId) {
+        return agentsCache.get(agentId);
+    }
+    // Only conversation agents belong to this plugin; the rest are owned
+    // by the built-in PromptAnalytics plugin.
+    function isConversationAgent(agent) {
+        return DOMConversation.supportedPreset(agent.preset);
+    }
+    function onConfigLoaded(aiAgents = []) {
+        if (!aiAgents || !_.isArray(aiAgents) || aiAgents.length === 0) {
+            return;
+        }
+        agentsCache.clear();
+        _.each(aiAgents, aiAgent => {
+            if (!isConversationAgent(aiAgent)) {
+                return;
+            }
+            agentsCache.set(aiAgent.id, aiAgent);
+            if (testPageRule(aiAgent.pageRule, aiAgent.id)) {
+                observeConversation(aiAgent);
+            }
+        });
+    }
+    function observeConversation(config) {
+        const { id, cssSelectors, privacyFilters } = config;
+        // Check if this agent is already being tracked
+        const existing = _.find(conversations, conversation => conversation.id === id);
+        if (existing) {
+            return;
+        }
+        const missing = DOMConversation.validateConfig(cssSelectors);
+        if (missing.length) {
+            log.error('aiAgent config missing required selectors', { agentId: id, missing });
+            return;
+        }
+        const conversation = new DOMConversation(pendo, api, id, privacyFilters, cssSelectors);
+        conversation.onSubmit(sendConversationEvent);
+        conversations.push(conversation);
+    }
+    function sendConversationEvent(eventType, eventPayload) {
+        // Block event if the conversation is suspended
+        const conversation = _.find(conversations, c => c.id === eventPayload.agentId);
+        if (conversation && !conversation.isActive) {
+            return;
+        }
+        eventPayload = _.extend({ agentType: 'conversation' }, eventPayload);
+        api.analytics.collectEvent(eventType, eventPayload, undefined, 'agentic');
+    }
+    function teardown() {
+        _.each(conversations, conversation => conversation.teardown());
+        conversations = [];
+        agentsCache.clear();
+    }
+}
+
+export { ConsoleCapture, ConversationAnalytics, Feedback, GuideMarkdown, NetworkCapture, PredictGuides, createReplayPlugin as Replay, TextCapture, VocPortal, loadAgent };