@pendo/agent 2.298.2 → 2.299.0

package/dist/pendo.module.js

@@ -3151,7 +3151,6 @@ var ConfigReader = (function () {
          * @type {boolean}
          */
         addOption('enableDebugEvents', [SNIPPET_SRC, PENDO_CONFIG_SRC]);
-        addOption('freeNPSData');
         addOption('eventPropertyConfigurations');
         /**
          * By default, a click event property rule can be matched against the element that is clicked on or its
@@ -3539,7 +3538,9 @@ var ConfigReader = (function () {
         addOption('enableAllEmbeddedGuideEvents', [PENDO_CONFIG_SRC], false);
         // Form Validation
         addOption('formValidation', [PENDO_CONFIG_SRC], false);
+        // Performance Metrics
         addOption('performanceMetricsEnabled', [SNIPPET_SRC, PENDO_CONFIG_SRC], true);
+        addOption('sendPerformanceMetrics', [SNIPPET_SRC, PENDO_CONFIG_SRC], false);
     }
     initializeOptions();
     var sourceGetters = {};
@@ -3904,8 +3905,8 @@ let SERVER = '';
 let ASSET_HOST = '';
 let ASSET_PATH = '';
 let DESIGNER_SERVER = '';
-let VERSION = '2.298.2_';
-let PACKAGE_VERSION = '2.298.2';
+let VERSION = '2.299.0_';
+let PACKAGE_VERSION = '2.299.0';
 let LOADER = 'xhr';
 /* eslint-enable agent-eslint-rules/no-gulp-env-references */
 /**
@@ -9792,18 +9793,18 @@ function writeErrorPOST(msg) {
  */
 function writeMetricsPOST(payload) {
     try {
-        const url = `${HOST}/data/agentmetrics?apiKey=${pendo$1.apiKey}`;
-        log.debug(`Will send ${JSON.stringify(payload)} to ${url} using ${fetchKeepalive.supported() ? 'fetch' : 'xhr'} once the endpoint exists`);
+        const url = `${HOST}/data/agentmetrics/${pendo$1.apiKey}`;
+        log.debug(`Sending ${JSON.stringify(payload)} to ${url} using ${fetchKeepalive.supported() ? 'fetch' : 'xhr'}`);
         if (fetchKeepalive.supported()) {
-            // fetch(url, {
-            //     method: 'POST',
-            //     keepalive: true,
-            //     body: JSON.stringify(payload),
-            //     headers: { 'Content-Type': 'application/json' }
-            // });
+            fetch(url, {
+                method: 'POST',
+                keepalive: true,
+                body: JSON.stringify(payload),
+                headers: { 'Content-Type': 'application/json' }
+            });
         }
         else {
-            // ajax.postJSON(url, payload);
+            ajax.postJSON(url, payload);
         }
     }
     catch (e) {
@@ -11275,7 +11276,7 @@ const trimString = (str, limit) => {
     return trimSurrogate(str.substring(0, limit));
 };
 function getTextValue(elem, limit) {
-    if (elem.tagName && ['textarea', 'input'].indexOf(elem.tagName.toLowerCase()) > -1) {
+    if (elem.tagName && _.contains(['textarea', 'input'], elem.tagName.toLowerCase())) {
         return trimString(elem.value, limit);
     }
     return getText(elem, limit);
@@ -12225,27 +12226,50 @@ var localStorageEventBuffer = new LocalStorageEventBuffer();
  *
  * See https://opentelemetry.io/docs/concepts/signals/metrics/#metric-instruments
  */
-const count = (entries) => {
-    if (!entries)
-        return 0;
-    if (entries instanceof Array) {
-        return _.reduce(entries, (count, e) => {
-            const incr = e.detail && e.detail.incr ? e.detail.incr : 1;
-            return count + incr;
-        }, 0);
-    }
-    return 0;
+const counter = (entries) => {
+    return _.reduce(entries, (count, entry) => {
+        return count + _.get(entry, 'detail.increment', 1);
+    }, 0);
 };
 
-const METRIC_GUIDELOOP_TIMEOUT = 'agent-guideloop-timeout';
-const Metrics = {};
-Metrics[METRIC_GUIDELOOP_TIMEOUT] = {
-    displayName: 'Guide Loop Timeouts',
-    name: METRIC_GUIDELOOP_TIMEOUT,
-    instrument: count
+const GUIDE_LOOP_TIMEOUT = 'pendo-guide-loop-timeout';
+const BEACON_GIF_FAILURES = {
+    ptm: 'pendo-ptm-gif-failure',
+    guide: 'pendo-guide-gif-failure',
+    poll: 'pendo-poll-gif-failure',
+    agentic: 'pendo-agentic-gif-failure'
+};
+const GUIDE_LOOP_TIMER = 'pendo-guide-loop';
+const EVENT_CAPTURED_TIMER = 'pendo-event-captured';
+const INITIALIZE = 'pendo-initialize';
+const TEARDOWN = 'pendo-teardown';
+const METRICS = {};
+METRICS[GUIDE_LOOP_TIMEOUT] = {
+    name: GUIDE_LOOP_TIMEOUT,
+    type: 'counter',
+    instrument: counter
+};
+_.each(BEACON_GIF_FAILURES, (name) => {
+    METRICS[name] = {
+        name,
+        type: 'counter',
+        instrument: counter
+    };
+});
+METRICS[GUIDE_LOOP_TIMER] = {
+    name: GUIDE_LOOP_TIMER
+};
+METRICS[EVENT_CAPTURED_TIMER] = {
+    name: EVENT_CAPTURED_TIMER
+};
+METRICS[INITIALIZE] = {
+    name: INITIALIZE
+};
+METRICS[TEARDOWN] = {
+    name: TEARDOWN
 };
 
-const PERF_INTERVAL = 1000 * 60 * 10;
+const PERFORMANCE_SEND_INTERVAL = 1000 * 60 * 10; // 10 minutes
 class PerformanceMonitor {
     constructor() {
         this._isPerformanceApiAvailable = this._checkPerformanceApi();
@@ -12255,42 +12279,55 @@ class PerformanceMonitor {
     }
     initialize() {
         this._measuringPerformance = true;
-        this._markPerformance('initialize');
+        this._markPerformance(INITIALIZE);
         this.interval = setInterval(() => {
             this.send();
-        }, PERF_INTERVAL);
+        }, PERFORMANCE_SEND_INTERVAL);
         return () => {
             this.teardown();
         };
     }
     teardown() {
+        this._markPerformance(TEARDOWN);
+        this.send();
         this._measuringPerformance = false;
         this._clearMarksAndMeasures();
         clearInterval(this.interval);
     }
-    startTimer(name) {
-        this._markPerformance(`${name}-start`);
+    startTimer(name, detail = null) {
+        this._markPerformance(`${name}-start`, { detail });
     }
-    stopTimer(name) {
-        this._markPerformance(`${name}-stop`);
-        this._measurePerformance(name);
+    stopTimer(name, detail = null) {
+        this._markPerformance(`${name}-stop`, { detail });
+        this._measurePerformance(name, { detail });
     }
-    count(name, incr = 1) {
-        this._markPerformance(name, {
-            detail: { type: 'count', incr }
-        });
+    count(name, increment = 1) {
+        const detail = increment > 1 ? { type: 'counter', increment } : null;
+        this._markPerformance(name, { detail });
     }
     send() {
-        const metrics = _.reduce(_.keys(Metrics), (acc, name) => {
+        const metrics = _.reduce(METRICS, (acc, metric) => {
+            const { name, type, instrument } = metric;
+            if (!instrument)
+                return acc;
             const entries = performance.getEntriesByName(name);
-            const value = Metrics[name].instrument(entries);
-            acc.push({ name, value });
+            const value = instrument(entries);
+            if (type === 'counter' && value > 0) {
+                acc.push({
+                    name,
+                    type,
+                    value,
+                    timestamp: Date.now()
+                });
+            }
             return acc;
         }, []);
         const payload = _.filter(metrics, (metric) => {
             return metric.value > 0;
         });
         this._clearMarksAndMeasures();
+        if (!ConfigReader.get('sendPerformanceMetrics'))
+            return;
         if (_.size(payload)) {
             writeMetricsPOST(payload);
         }
@@ -12307,39 +12344,34 @@ class PerformanceMonitor {
     _shouldMeasurePerformance() {
         return this._isPerformanceApiAvailable && this._measuringPerformance;
     }
-    _markPerformance(name, attr) {
+    _markPerformance(name, metadata) {
         if (!this._shouldMeasurePerformance())
             return;
-        name = `pendo-${name}`;
-        performance.mark(name);
+        performance.mark(name, metadata);
         this.marks.add(name);
     }
-    _measurePerformance(name) {
+    _measurePerformance(name, metadata) {
         if (!this._shouldMeasurePerformance())
             return;
-        name = `pendo-${name}`;
         const startMark = `${name}-start`;
         const stopMark = `${name}-stop`;
         if (performance.getEntriesByName(startMark).length && performance.getEntriesByName(stopMark).length) {
-            performance.measure(name, startMark, stopMark);
+            performance.measure(name, startMark, stopMark, metadata);
             this.measures.add(name);
         }
     }
     _clearMarksAndMeasures() {
-        // TODO: fix custom lint rule to handle sets
-        // eslint-disable-next-line agent-eslint-rules/no-array-foreach
-        this.marks.forEach(name => {
+        for (const name of this.marks) {
             performance.clearMarks(name);
-        });
+        }
         this.marks.clear();
-        // eslint-disable-next-line agent-eslint-rules/no-array-foreach
-        this.measures.forEach(name => {
+        for (const name of this.measures) {
             performance.clearMeasures(name);
-        });
+        }
         this.measures.clear();
     }
 }
-const _PerformanceMonitor = new PerformanceMonitor();
+const performanceMonitor = new PerformanceMonitor();
 
 var defaultTrackName = '_PENDO_UNNAMED_';
 var SILO_AVG_COMPRESSION_RATIO = 5;
@@ -12391,9 +12423,6 @@ function collectEvent(type, props, url, name, eventProperties, context) {
     if (!isURLValid(event.url)) {
         return;
     }
-    if (!eventIsWhitelisted(event)) {
-        return;
-    }
     if (type === 'track') {
         trackEventQueue.push(event);
         return;
@@ -12404,19 +12433,6 @@ function collectEvent(type, props, url, name, eventProperties, context) {
     }
     eventQueue.push(event);
 }
-// @const {Event.type[]}
-var WHITELIST_FREE_NPS = ['load', 'meta', 'identify'];
-/**
- * @access private
- * @param {Event} event to consider
- * @returns {boolean} whether {event} is allowed
- */
-function eventIsWhitelisted(event) {
-    if (ConfigReader.get('freeNPSData')) {
-        return _.contains(WHITELIST_FREE_NPS, event.type);
-    }
-    return true;
-}
 function pipeline() {
     var args = _.toArray(arguments);
     return function generatedPipeline(obj, next) {
@@ -12841,7 +12857,7 @@ function createSendQueue(options, send, guaranteedSend) {
             }
         });
         queue.onTimeout = function () {
-            _PerformanceMonitor.count(`${options.beacon}-gif-failure`);
+            performanceMonitor.count(BEACON_GIF_FAILURES[options.beacon]);
         };
         queue.retryPending = true;
         return queue;
@@ -13240,11 +13256,12 @@ function attributeSerializer(context, node) {
 
 function childIndexSerializer(context, node) {
     if (node.parentNode && node.parentNode.childNodes) {
-        var nodes = _.chain(node.parentNode.childNodes);
+        const nodes = _.chain(node.parentNode.childNodes);
         context.myIndex = nodes.indexOf(node).value();
-        context.childIndex = nodes.filter(function (n) {
+        const childNodes = nodes.filter(function (n) {
             return n.nodeType == ELEMENT;
-        }).indexOf(node).value();
+        });
+        context.childIndex = childNodes.indexOf(node).value();
     }
     return context;
 }
@@ -13373,7 +13390,7 @@ var getValidTarget = function (node) {
  */
 var handle_event = function (evt) {
     try {
-        _PerformanceMonitor.startTimer('event-captured');
+        performanceMonitor.startTimer(EVENT_CAPTURED_TIMER);
         if (dom.data.get(evt, 'counted'))
             return;
         dom.data.set(evt, 'counted', true);
@@ -13414,7 +13431,7 @@ var handle_event = function (evt) {
         log.critical('pendo.io while handling event', { error: e });
     }
     finally {
-        _PerformanceMonitor.stopTimer('event-captured');
+        performanceMonitor.stopTimer(EVENT_CAPTURED_TIMER);
     }
 };
 function getClickEventProperties(target) {
@@ -19408,6 +19425,9 @@ var BuildingBlockResourceCenter = (function () {
         webWidgetWrapper(provider, 'messenger:on', 'unreadMessages', function (unreadCount) {
             updateNotificationBubbleCount(unreadCount, 'chat');
         });
+        if (resourceCenter.isInProgress() && !resourceCenter.attributes.doNotResume) {
+            handleNativeIntegrationContinuation(resourceCenter.activeModule);
+        }
     }
     // Zendesk Native Chat API - https://developer.zendesk.com/embeddables/docs/widget/chat_api_migration
     function configureZendeskChatSettings(integrationObj) {
@@ -20399,17 +20419,18 @@ var GuideStateModule = (function () {
         updateLastGuideStepSeen(context, lastGuideStepSeen) {
             if (lastGuideStepSeen.visitorId && lastGuideStepSeen.visitorId !== context.getters.visitorId())
                 return;
-            const isValidGuide = _.some(context.getters.guideList(), function ({ id }) {
+            // Embedded guides should not update the lastGuideStepSeen in order to not interfere with auto guide display
+            // Embedded guides are not included in getters.guideList
+            const shouldUpdateLastGuideStepSeen = _.some(context.getters.guideList(), function ({ id }) {
                 return id === lastGuideStepSeen.guideId;
             });
             if (lastGuideStepSeen.guideStepId) {
                 context.commit('setStepState', lastGuideStepSeen);
             }
-            if (!isValidGuide) {
-                return;
+            if (shouldUpdateLastGuideStepSeen) {
+                context.commit('setLastGuideStepSeen', lastGuideStepSeen);
+                pendo$1.lastGuideStepSeen = lastGuideStepSeen;
             }
-            context.commit('setLastGuideStepSeen', lastGuideStepSeen);
-            pendo$1.lastGuideStepSeen = lastGuideStepSeen;
             if (guideCache) {
                 guideCache.update(lastGuideStepSeen);
             }
@@ -21385,7 +21406,7 @@ class UpdateRunner {
             monitor.start();
             promise = currentPhase.process(monitor);
             if (!promise && monitor.isTimeExceeded()) {
-                _PerformanceMonitor.count(METRIC_GUIDELOOP_TIMEOUT);
+                performanceMonitor.count(GUIDE_LOOP_TIMEOUT);
                 if (currentPhase.handleProcessTimeExceeded) {
                     currentPhase.handleProcessTimeExceeded(monitor);
                 }
@@ -26553,10 +26574,34 @@ const PENDO_HEADERS_KEY = '_pendoHeaders';
 function getTransformedUrl(url) {
     return store.getters['networkUrl/getTransformedUrl']()(url);
 }
+const HEADERS = 'headers';
+const DENIED_HEADERS = {
+    'authorization': true,
+    'cookie': true,
+    'set-cookie': true,
+    'x-api-key': true,
+    'x-forwarded-for': true,
+    'proxy-authorization': true,
+    'signature': true,
+    'forwarded': true,
+    'referrer': true
+};
+const XSRF = 'xsrf';
+const CSRF = 'csrf';
+const MAX_RESPONSE_SIZE = 1024 * 1024 * 2; // 2MB
+const MAX_RESPONSE_SIZE_MESSAGE = '[Body too large to capture (over 2 MB)]';
 class NetworkRequestIntercept {
-    entriesToObject(entries) {
+    // Headers that should never be captured by pendo for PII/security reasons.
+    isDeniedHeader(key) {
+        const normalizedKey = key.toLowerCase();
+        return DENIED_HEADERS[normalizedKey] || normalizedKey.indexOf(CSRF) !== -1 || normalizedKey.indexOf(XSRF) !== -1;
+    }
+    entriesToObject(entries, type) {
         const obj = {};
         for (const [key, value] of entries) {
+            if (type === HEADERS && this.isDeniedHeader(key)) {
+                continue;
+            }
             obj[key] = value;
         }
         return obj;
@@ -26580,11 +26625,14 @@ class NetworkRequestIntercept {
     extractHeaders(headers = {}) {
         let result = {};
         if (headers instanceof Headers) {
-            result = this.entriesToObject(headers.entries());
+            result = this.entriesToObject(headers.entries(), HEADERS);
         }
         else if (typeof headers === 'object') {
             for (const key in headers) {
                 if (headers.hasOwnProperty(key)) {
+                    if (this.isDeniedHeader(key)) {
+                        continue;
+                    }
                     result[key] = headers[key];
                 }
             }
@@ -26601,17 +26649,25 @@ class NetworkRequestIntercept {
     safelyReadBody(config, type) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                const contentType = config.headers.get('content-type') || '';
-                if (contentType.indexOf('application/json') !== -1) {
-                    return yield config.json();
-                }
-                else if (contentType.indexOf('text/') !== -1) {
-                    return yield config.text();
+                const contentType = config.headers.get('content-type') || 'unknown';
+                const contentLengthHeader = config.headers.get('content-length');
+                // Check if content type is readable (text or JSON)
+                const isReadableContent = contentType.indexOf('text/') !== -1 || contentType.indexOf('application/json') !== -1;
+                if (!isReadableContent) {
+                    const typeDisplay = contentType;
+                    return `[Binary content: ${typeDisplay}]`;
+                }
+                if (contentLengthHeader) {
+                    const size = parseInt(contentLengthHeader, 10);
+                    if (size > MAX_RESPONSE_SIZE) {
+                        return MAX_RESPONSE_SIZE_MESSAGE;
+                    }
                 }
-                else {
-                    // For binary or unknown content types, just capture metadata
-                    return `[Binary content: ${contentType}]`;
+                const text = yield config.text();
+                if (text.length > MAX_RESPONSE_SIZE) {
+                    return MAX_RESPONSE_SIZE_MESSAGE;
                 }
+                return text;
             }
             catch (e) {
                 return `[Unable to read ${type} body]`;
@@ -26622,7 +26678,7 @@ class NetworkRequestIntercept {
         let headers = {};
         if (config.headers) {
             const headerEntries = Array.from(config.headers.entries());
-            headers = this.entriesToObject(headerEntries);
+            headers = this.entriesToObject(headerEntries, HEADERS);
         }
         return headers;
     }
@@ -26793,7 +26849,8 @@ class NetworkRequestIntercept {
                 if (xhr.readyState === 4) { // Request completed
                     try {
                         const headers = networkInterceptor.parseXHRResponseHeaders(xhr.getAllResponseHeaders());
-                        const { status, statusText, responseText: body, _url } = xhr;
+                        const { status, statusText, _url } = xhr;
+                        const body = networkInterceptor.safelyReadXHRResponse(xhr, headers);
                         _.each(networkInterceptor.callbackFns, ({ response }) => {
                             if (_.isFunction(response)) {
                                 response({
@@ -26822,6 +26879,21 @@ class NetworkRequestIntercept {
             return networkInterceptor._originalXHRSend.apply(this, arguments);
         };
     }
+    safelyReadXHRResponse(xhr, headers) {
+        const networkInterceptor = this;
+        const size = networkInterceptor.estimateResponseSize(headers['content-length'], xhr.responseText);
+        if (size > MAX_RESPONSE_SIZE) {
+            return MAX_RESPONSE_SIZE_MESSAGE;
+        }
+        return xhr.responseText;
+    }
+    estimateResponseSize(contentLength, responseText) {
+        const parsedContentLength = parseInt(contentLength, 10);
+        if (!_.isNumber(parsedContentLength) || isNaN(parsedContentLength)) {
+            return responseText.length;
+        }
+        return parsedContentLength;
+    }
     patchNetwork() {
         const networkInterceptor = this;
         if (networkInterceptor._networkPatched)
@@ -28357,7 +28429,7 @@ const initialize = makeSafe(function (options) {
         Events.appUsage.on(GuideActivity.handler);
         Events.appUsage.on(ResourceCenterActivity.handler);
         teardownFns.push(flushEvery(SEND_INTERVAL));
-        teardownFns.push(_PerformanceMonitor.initialize());
+        teardownFns.push(performanceMonitor.initialize());
     }
     Events.appHidden.on(() => {
         flushNow(true, { hidden: true });
@@ -29398,8 +29470,10 @@ function track(name, props) {
     collectEventHelper({ type: 'track', name, props });
 }
 
+const privacyFilterCache = new Map();
 /**
  * Method to manually track agentic events. Uses agent functions for IDs and context.
+ * Automatically applies privacy filters if agentId is provided and agent configuration exists.
  *
  * @access public
  * @category Events
@@ -29418,8 +29492,64 @@ function track(name, props) {
  * })
  */
 function trackAgent(type, props) {
+    const filteredTypes = ['prompt', 'system_response'];
+    if (_.contains(filteredTypes, type)) {
+        props = applyPrivacyFilters(props);
+    }
     collectEventHelper({ type, name: 'agentic', props });
 }
+/**
+ * Apply privacy filters to event properties based on agent configuration
+ * Optimized for maximum performance with caching
+ * @param {Object} props - Event properties to filter
+ * @returns {Object} - Filtered properties
+ */
+function applyPrivacyFilters(props) {
+    if (!(props === null || props === void 0 ? void 0 : props.agentId)) {
+        return props;
+    }
+    try {
+        const agents = ConfigReader.get('aiAgents', []);
+        const agent = (agents === null || agents === void 0 ? void 0 : agents.find(agent => agent.id === props.agentId)) || null;
+        const content = props.content;
+        if (!content) {
+            return props;
+        }
+        if (!(agent === null || agent === void 0 ? void 0 : agent.privacyFilters)) {
+            return props;
+        }
+        const privacyFilter = getCachedRegex(agent.privacyFilters);
+        if (!privacyFilter) {
+            return props;
+        }
+        const filteredContent = content.replace(privacyFilter, '<redacted>');
+        if (filteredContent === content) {
+            return props;
+        }
+        return Object.assign(Object.assign({}, props), { content: filteredContent });
+    }
+    catch (error) {
+        console.error('Error applying privacy filters', error);
+        return props;
+    }
+}
+/**
+ * Get cached regex or compile and cache new one
+ */
+function getCachedRegex(filterPattern) {
+    let regex = privacyFilterCache.get(filterPattern);
+    if (!regex) {
+        try {
+            regex = new RegExp(filterPattern, 'gmi');
+            privacyFilterCache.set(filterPattern, regex);
+        }
+        catch (e) {
+            privacyFilterCache.set(filterPattern, null);
+            return null;
+        }
+    }
+    return regex;
+}
 
 /**
  * Checks visitor and account metadata in the current Pendo installation. Either logs to console
@@ -33411,12 +33541,12 @@ var GuideUpdateModule = (function () {
             state.scheduledUpdate = scheduledUpdate;
         },
         startUpdate(state, time) {
-            _PerformanceMonitor.startTimer('guide-loop');
+            performanceMonitor.startTimer(GUIDE_LOOP_TIMER);
             state.needsUpdate = false;
             state.updateId = time;
         },
         completeUpdate(state, time) {
-            _PerformanceMonitor.stopTimer('guide-loop');
+            performanceMonitor.stopTimer(GUIDE_LOOP_TIMER);
             state.updateId = null;
             state.updateCompleteTime = time;
         }
@@ -38201,7 +38331,7 @@ const EmbeddedGuides = (function () {
         return { guide, step };
     }
     function initializeEmbeddedGuides() {
-        restoreFromPreviouseGuides();
+        restoreFromPreviousGuides();
         pluginApi.guides.registerDisplayableGuides('embeddedGuides', embeddedGuides);
         applyEmbeddedGuideBehaviors();
     }
@@ -38216,7 +38346,7 @@ const EmbeddedGuides = (function () {
     // When a guides payload is received, the embedded guides list is cleared and cached in _oldEmbeddedGuides.
     // This function replaces guides in the new payload with guides from the previous payload to prevent re-rendering.
     // Additionally, if guides from the previous payload are showing, and they are not in the new payload, this function hides them.
-    function restoreFromPreviouseGuides() {
+    function restoreFromPreviousGuides() {
         _.each(_oldEmbeddedGuides, function (oldGuide) {
             const newGuideIndex = _.findIndex(embeddedGuides, function (guide) {
                 return guide.id === oldGuide.id;
@@ -54690,9 +54820,7 @@ const ErrorStackParser = {
             // if a location was matched, pass it to extractLocation() otherwise pop the last token
             const locationParts = this.extractLocation(location ? location[1] : tokens.pop() || '');
             const functionName = tokens.join(' ') || undefined;
-            const fileName = ['eval', '<anonymous>'].indexOf(locationParts[0]) > -1
-                ? undefined
-                : locationParts[0];
+            const fileName = (locationParts[0] === 'eval' || locationParts[0] === '<anonymous>') ? undefined : locationParts[0];
             frames.push(new StackFrame({
                 functionName,
                 fileName,
@@ -54734,17 +54862,29 @@ const PII_PATTERN = {
     ip: /\b(?:\d{1,3}\.){3}\d{1,3}\b/g,
     ssn: /\b\d{3}-\d{2}-\d{4}\b/g,
     creditCard: /\b(?:\d[ -]*?){13,16}\b/g,
-    httpsUrls: /https:\/\/[^\s]+/g
+    httpsUrls: /https:\/\/[^\s]+/g,
+    email: /\b\S+@[\w-]+\.[\w-]+\b/g
 };
 const PII_REPLACEMENT = '*'.repeat(10);
+const JSON_PII_KEYS = ['password', 'email', 'key', 'token', 'auth', 'authentication', 'phone', 'address', 'ssn'];
+const UNABLE_TO_DISPLAY_BODY = '[Unable to display body: detected PII could not be redacted]';
+const joinedKeys = JSON_PII_KEYS.join('|');
+const keyPattern = `"([^"]*(?:${joinedKeys})[^"]*)"`;
+// only scrub strings, numbers, and booleans
+const acceptedValues = '("([^"\\\\]*(?:\\\\.[^"\\\\]*)*")|(\\d+)|(true|false))';
 /**
  * Truncates a string to the max length
  * @access private
  * @param {String} string
  * @returns {String}
  */
-function truncate(string) {
-    return string.length > MAX_LENGTH ? string.slice(0, MAX_LENGTH) : string;
+function truncate(string, includeEllipsis = false) {
+    if (string.length <= MAX_LENGTH)
+        return string;
+    if (includeEllipsis) {
+        return string.slice(0, MAX_LENGTH).concat('...');
+    }
+    return string.slice(0, MAX_LENGTH);
 }
 /**
  * Generate a log key for a console log separated by pipes
@@ -54758,13 +54898,13 @@ function generateLogKey(methodName, message, stackTrace) {
     return `${methodName}|${message}|${stackTrace}`;
 }
 /**
- * Checks if a string has 2 or more digits or a https URL
+ * Checks if a string has 2 or more digits, a https URL, or an email address
  * @access private
  * @param {String} string
  * @returns {Boolean}
  */
 function mightContainPII(string) {
-    return /[\d]{2,}|https:\/\//.test(string);
+    return /[\d]{2,}|https:\/\/|@/.test(string);
 }
 /**
  * Scrub basic PII from a string and replace it with a placeholder
@@ -54772,12 +54912,60 @@ function mightContainPII(string) {
  * @param {String} string
  * @returns {String}
  */
-function scrubPII(string) {
+function scrubPII({ string, _ }) {
     if (!string || typeof string !== 'string')
         return string;
     if (!mightContainPII(string))
         return string;
-    return Object.values(PII_PATTERN).reduce((str, pattern) => str.replace(pattern, PII_REPLACEMENT), string);
+    return _.reduce(_.values(PII_PATTERN), (str, pattern) => str.replace(pattern, PII_REPLACEMENT), string);
+}
+/**
+ * Scrub PII from a stringified JSON object
+ * @access private
+ * @param {String} string
+ * @returns {String}
+ */
+function scrubJsonPII(string) {
+    const fullScrubRegex = new RegExp(`${keyPattern}\\s*:\\s*[\\{\\[]`, 'i');
+    if (fullScrubRegex.test(string)) {
+        return UNABLE_TO_DISPLAY_BODY;
+    }
+    const keyValueScrubRegex = new RegExp(`${keyPattern}\\s*:\\s*${acceptedValues}`, 'gi');
+    return string.replace(keyValueScrubRegex, (match, key) => `"${key}":"${PII_REPLACEMENT}"`);
+}
+/**
+ * Checks if a string is a JSON object
+ * @access private
+ * @param {String} string
+ * @param {String} contentType
+ * @returns {Boolean}
+ */
+function mightContainJson(string, contentType) {
+    if (!string || typeof string !== 'string')
+        return false;
+    const firstChar = string.charAt(0);
+    if (contentType && contentType.indexOf('application/json') !== -1) {
+        return true;
+    }
+    return firstChar === '{' || firstChar === '[';
+}
+/**
+ * Mask sensitive fields in a string
+ * @access private
+ * @param {String} string
+ * @param {String} contentType
+ * @returns {String}
+ */
+function maskSensitiveFields({ string, contentType, _ }) {
+    if (!string || typeof string !== 'string')
+        return string;
+    if (mightContainJson(string, contentType)) {
+        string = scrubJsonPII(string);
+    }
+    if (mightContainPII(string)) {
+        string = scrubPII({ string, _ });
+    }
+    return string;
 }
 
 /**
@@ -54952,11 +55140,10 @@ function createCspViolationMessage(blockedURI, directive, isReportOnly, original
     }
 }
 
-const DEV_LOG_LEVELS = ['info', 'warn', 'error'];
 const TOKEN_MAX_SIZE = 100;
 const TOKEN_REFILL_RATE = 10;
 const TOKEN_REFRESH_INTERVAL = 1000;
-class ConsoleCaptureBuffer {
+class DevlogBuffer {
     constructor(pendo, pluginAPI) {
         this.pendo = pendo;
         this.pluginAPI = pluginAPI;
@@ -54985,9 +55172,6 @@ class ConsoleCaptureBuffer {
         this.lastEvent = null;
     }
     push(event) {
-        const { devLogLevel } = event;
-        if (!this.pendo._.contains(DEV_LOG_LEVELS, devLogLevel))
-            return false;
         this.refillTokens();
         if (this.tokens === 0)
             return false;
@@ -55804,7 +55988,6 @@ var ConfigReader = (function () {
          * @type {boolean}
          */
         addOption('enableDebugEvents', [SNIPPET_SRC, PENDO_CONFIG_SRC]);
-        addOption('freeNPSData');
         addOption('eventPropertyConfigurations');
         /**
          * By default, a click event property rule can be matched against the element that is clicked on or its
@@ -56192,7 +56375,9 @@ var ConfigReader = (function () {
         addOption('enableAllEmbeddedGuideEvents', [PENDO_CONFIG_SRC], false);
         // Form Validation
         addOption('formValidation', [PENDO_CONFIG_SRC], false);
+        // Performance Metrics
         addOption('performanceMetricsEnabled', [SNIPPET_SRC, PENDO_CONFIG_SRC], true);
+        addOption('sendPerformanceMetrics', [SNIPPET_SRC, PENDO_CONFIG_SRC], false);
     }
     initializeOptions();
     var sourceGetters = {};
@@ -56981,7 +57166,7 @@ else {
 var SEND_INTERVAL = 2 * 60 * 1000;
 var ENCODED_EVENT_MAX_LENGTH = 1900;
 
-class ConsoleTransport {
+class DevlogTransport {
     constructor(globalPendo, pluginAPI) {
         this.pendo = globalPendo;
         this.pluginAPI = pluginAPI;
@@ -57025,7 +57210,7 @@ class ConsoleTransport {
         }
         else if (options.keepalive && this.pluginAPI.transmit.sendBeacon.supported()) {
             const result = this.pluginAPI.transmit.sendBeacon(url, new Blob([options.body]));
-            return result ? Promise$2.resolve() : Promise$2.reject(new Error('sendBeacon failed to send console data'));
+            return result ? Promise$2.resolve() : Promise$2.reject(new Error('sendBeacon failed to send devlog data'));
         }
         else {
             return this.pendo.ajax.post(url, options.body);
@@ -57060,6 +57245,17 @@ class ConsoleTransport {
     }
 }
 
+const DEV_LOG_TYPE = 'devlog';
+function createDevLogEnvelope(pluginAPI, globalPendo) {
+    return {
+        browser_time: pluginAPI.util.getNow(),
+        url: globalPendo.url.get(),
+        visitorId: globalPendo.get_visitor_id(),
+        accountId: globalPendo.get_account_id(),
+        type: DEV_LOG_TYPE
+    };
+}
+
 function ConsoleCapture() {
     let pluginAPI;
     let _;
@@ -57071,7 +57267,6 @@ function ConsoleCapture() {
     let isPtmPaused;
     const CAPTURE_CONSOLE_CONFIG = 'captureConsoleLogs';
     const CONSOLE_METHODS = ['log', 'warn', 'error', 'info'];
-    const DEV_LOG_TYPE = 'devlog';
     const DEV_LOG_SUB_TYPE = 'console';
     // deduplicate logs
     let lastLogKey = '';
@@ -57107,8 +57302,8 @@ function ConsoleCapture() {
         if (!captureConsoleEnabled)
             return;
         globalPendo = pendo;
-        buffer = new ConsoleCaptureBuffer(pendo, pluginAPI);
-        transport = new ConsoleTransport(pendo, pluginAPI);
+        buffer = new DevlogBuffer(pendo, pluginAPI);
+        transport = new DevlogTransport(pendo, pluginAPI);
         sendQueue = new SendQueue(transport.sendRequest.bind(transport));
         sendInterval = setInterval(() => {
             if (!sendQueue.failed()) {
@@ -57141,16 +57336,6 @@ function ConsoleCapture() {
             send();
         }
     }
-    function createDevLogEnvelope() {
-        return {
-            visitorId: globalPendo.get_visitor_id(),
-            accountId: globalPendo.get_account_id(),
-            type: DEV_LOG_TYPE,
-            subType: DEV_LOG_SUB_TYPE,
-            browser_time: pluginAPI.util.getNow(),
-            url: globalPendo.url.get()
-        };
-    }
     function readyHandler() {
         addIntercepts();
         pluginAPI.attachEventInternal(window, 'securitypolicyviolation', securityPolicyViolationFn);
@@ -57186,7 +57371,7 @@ function ConsoleCapture() {
         }
     }
     function createConsoleEvent(args, methodName, { skipStackTrace = false, skipScrubPII = false } = {}) {
-        if (!args || args.length === 0)
+        if (!args || args.length === 0 || !_.contains(CONSOLE_METHODS, methodName))
             return;
         // stringify args
         let message = _.compact(_.map(args, arg => {
@@ -57216,8 +57401,8 @@ function ConsoleCapture() {
             buffer.lastEvent.devLogCount++;
             return;
         }
-        const devLogEnvelope = createDevLogEnvelope();
-        const consoleEvent = Object.assign(Object.assign({}, devLogEnvelope), { devLogLevel: methodName === 'log' ? 'info' : methodName, devLogMessage: skipScrubPII ? message : scrubPII(message), devLogTrace: stackTrace, devLogCount: 1 });
+        const devLogEnvelope = createDevLogEnvelope(pluginAPI, globalPendo);
+        const consoleEvent = Object.assign(Object.assign({}, devLogEnvelope), { subType: DEV_LOG_SUB_TYPE, devLogLevel: methodName === 'log' ? 'info' : methodName, devLogMessage: skipScrubPII ? message : scrubPII({ string: message, _ }), devLogTrace: stackTrace, devLogCount: 1 });
         const wasAccepted = buffer.push(consoleEvent);
         if (wasAccepted) {
             if (!isPtmPaused) {
@@ -57253,7 +57438,7 @@ function ConsoleCapture() {
             v: globalPendo.VERSION,
             ct: pluginAPI.util.getNow()
         };
-        const url = pluginAPI.transmit.buildBaseDataUrl('devlog', globalPendo.apiKey, queryParams);
+        const url = pluginAPI.transmit.buildBaseDataUrl(DEV_LOG_TYPE, globalPendo.apiKey, queryParams);
         const jzb = buffer.pack();
         if (!jzb)
             return;
@@ -57291,4 +57476,329 @@ function ConsoleCapture() {
     }
 }
 
-export { ConsoleCapture, Feedback, GuideMarkdown, createReplayPlugin as Replay, TextCapture, VocPortal, loadAgent };
+function NetworkCapture() {
+    let pluginAPI;
+    let globalPendo;
+    let requestMap = {};
+    let buffer;
+    let sendQueue;
+    let sendInterval;
+    let transport;
+    let isPtmPaused;
+    let requestBodyCb;
+    let responseBodyCb;
+    let pendoDevlogBaseUrl;
+    const CAPTURE_NETWORK_CONFIG = 'captureNetworkRequests';
+    const NETWORK_SUB_TYPE = 'network';
+    const NETWORK_LOGS_CONFIG = 'networkLogs';
+    const NETWORK_LOGS_CONFIG_ALLOWED_REQUEST_HEADERS = 'networkLogs.allowedRequestHeaders';
+    const NETWORK_LOGS_CONFIG_ALLOWED_RESPONSE_HEADERS = 'networkLogs.allowedResponseHeaders';
+    const NETWORK_LOGS_CONFIG_CAPTURE_REQUEST_BODY = 'networkLogs.captureRequestBody';
+    const NETWORK_LOGS_CONFIG_CAPTURE_RESPONSE_BODY = 'networkLogs.captureResponseBody';
+    const allowedRequestHeaders = {
+        'content-type': true, 'content-length': true, 'accept': true, 'accept-language': true
+    };
+    const allowedResponseHeaders = {
+        'cache-control': true, 'content-length': true, 'content-type': true, 'content-language': true
+    };
+    return {
+        name: 'NetworkCapture',
+        initialize,
+        teardown,
+        handleRequest,
+        handleResponse,
+        handleError,
+        startCapture,
+        createNetworkEvent,
+        send,
+        onPtmPaused,
+        onPtmUnpaused,
+        onAppHidden,
+        onAppUnloaded,
+        addConfigOptions,
+        processHeaderConfig,
+        extractHeaders,
+        setupBodyCallbacks,
+        processBody,
+        processRequestBody,
+        processResponseBody,
+        get requestMap() {
+            return requestMap;
+        },
+        get buffer() {
+            return buffer;
+        },
+        get sendQueue() {
+            return sendQueue;
+        },
+        get isPtmPaused() {
+            return isPtmPaused;
+        },
+        get allowedRequestHeaders() {
+            return allowedRequestHeaders;
+        },
+        get allowedResponseHeaders() {
+            return allowedResponseHeaders;
+        },
+        get requestBodyCb() {
+            return requestBodyCb;
+        },
+        get responseBodyCb() {
+            return responseBodyCb;
+        }
+    };
+    function initialize(pendo, PluginAPI) {
+        pluginAPI = PluginAPI;
+        globalPendo = pendo;
+        const { ConfigReader } = pluginAPI;
+        ConfigReader.addOption(CAPTURE_NETWORK_CONFIG, [ConfigReader.sources.PENDO_CONFIG_SRC], false);
+        const captureNetworkEnabled = ConfigReader.get(CAPTURE_NETWORK_CONFIG);
+        if (!captureNetworkEnabled)
+            return;
+        buffer = new DevlogBuffer(pendo, pluginAPI);
+        transport = new DevlogTransport(pendo, pluginAPI);
+        sendQueue = new SendQueue(transport.sendRequest.bind(transport));
+        addConfigOptions();
+        processHeaderConfig(NETWORK_LOGS_CONFIG_ALLOWED_REQUEST_HEADERS, allowedRequestHeaders);
+        processHeaderConfig(NETWORK_LOGS_CONFIG_ALLOWED_RESPONSE_HEADERS, allowedResponseHeaders);
+        setupBodyCallbacks();
+        sendInterval = setInterval(() => {
+            if (!sendQueue.failed()) {
+                send();
+            }
+        }, SEND_INTERVAL);
+        sendQueue.start();
+        pluginAPI.Events.ready.on(startCapture);
+        pluginAPI.Events['ptm:paused'].on(onPtmPaused);
+        pluginAPI.Events['ptm:unpaused'].on(onPtmUnpaused);
+        pluginAPI.Events.appHidden.on(onAppHidden);
+        pluginAPI.Events.appUnloaded.on(onAppUnloaded);
+        pendoDevlogBaseUrl = pluginAPI.transmit.buildBaseDataUrl(DEV_LOG_TYPE, globalPendo.apiKey);
+    }
+    function addConfigOptions() {
+        const { ConfigReader } = pluginAPI;
+        ConfigReader.addOption(NETWORK_LOGS_CONFIG, [ConfigReader.sources.SNIPPET_SRC], {});
+        /**
+         * Additional request headers to capture in network logs.
+         * Default headers are: `['content-type', 'content-length', 'accept', 'accept-language']`
+         *
+         * @access public
+         * @category Config/Network Logs
+         * @name networkLogs.allowedRequestHeaders
+         * @default []
+         * @type {string[]}
+         */
+        ConfigReader.addOption(NETWORK_LOGS_CONFIG_ALLOWED_REQUEST_HEADERS, [ConfigReader.sources.SNIPPET_SRC], []);
+        /**
+         * Additional response headers to capture in network logs.
+         * Default headers are: `['cache-control', 'content-length', 'content-type', 'content-language']`
+         *
+         * @access public
+         * @category Config/Network Logs
+         * @name networkLogs.allowedResponseHeaders
+         * @default []
+         * @type {string[]}
+         */
+        ConfigReader.addOption(NETWORK_LOGS_CONFIG_ALLOWED_RESPONSE_HEADERS, [ConfigReader.sources.SNIPPET_SRC], []);
+        /**
+         * Callback function to process/modify request bodies before capturing them. If not provided, the request body will not be captured.
+         *
+         * @access public
+         * @category Config/Network Logs
+         * @name networkLogs.captureRequestBody
+         * @default undefined
+         * @type {function}
+         */
+        ConfigReader.addOption(NETWORK_LOGS_CONFIG_CAPTURE_REQUEST_BODY, [ConfigReader.sources.SNIPPET_SRC], undefined);
+        /**
+         * Callback function to process/modify response bodies before capturing them. If not provided, the response body will not be captured.
+         *
+         * @access public
+         * @category Config/Network Logs
+         * @name networkLogs.captureResponseBody
+         * @default undefined
+         * @type {function}
+         */
+        ConfigReader.addOption(NETWORK_LOGS_CONFIG_CAPTURE_RESPONSE_BODY, [ConfigReader.sources.SNIPPET_SRC], undefined);
+    }
+    function processHeaderConfig(configHeaderName, targetHeaders) {
+        const configHeaders = pluginAPI.ConfigReader.get(configHeaderName);
+        if (!configHeaders || configHeaders.length === 0)
+            return;
+        globalPendo._.each(configHeaders, (header) => {
+            if (!header || typeof header !== 'string')
+                return;
+            targetHeaders[header.toLowerCase()] = true;
+        });
+    }
+    function setupBodyCallbacks() {
+        const config = pluginAPI.ConfigReader.get(NETWORK_LOGS_CONFIG);
+        if (!config)
+            return;
+        if (globalPendo._.isFunction(config.captureRequestBody)) {
+            requestBodyCb = config.captureRequestBody;
+        }
+        if (globalPendo._.isFunction(config.captureResponseBody)) {
+            responseBodyCb = config.captureResponseBody;
+        }
+    }
+    function onPtmPaused() {
+        isPtmPaused = true;
+    }
+    function onPtmUnpaused() {
+        isPtmPaused = false;
+        if (!buffer.isEmpty()) {
+            for (const event of buffer.events) {
+                pluginAPI.Events.eventCaptured.trigger(event);
+            }
+            send();
+        }
+    }
+    function onAppHidden() {
+        send({ hidden: true });
+    }
+    function onAppUnloaded() {
+        send({ unload: true });
+    }
+    function startCapture() {
+        pluginAPI.NetworkRequest.on({ request: handleRequest, response: handleResponse, error: handleError });
+    }
+    function teardown() {
+        if (sendInterval) {
+            clearInterval(sendInterval);
+        }
+        if (sendQueue) {
+            sendQueue.stop();
+        }
+        if (buffer) {
+            buffer.clear();
+        }
+        pluginAPI.NetworkRequest.off({ request: handleRequest, response: handleResponse, error: handleError });
+        requestMap = {};
+        pluginAPI.Events['ptm:paused'].off(onPtmPaused);
+        pluginAPI.Events['ptm:unpaused'].off(onPtmUnpaused);
+        pluginAPI.Events.appHidden.off(onAppHidden);
+        pluginAPI.Events.appUnloaded.off(onAppUnloaded);
+    }
+    function handleRequest(request) {
+        requestMap[request.requestId] = request;
+    }
+    function handleResponse(response) {
+        if (!response)
+            return;
+        const request = requestMap[response.requestId];
+        if (!request)
+            return;
+        // Skip capturing successful devlog events to avoid infinite loops
+        if (request.url.indexOf(pendoDevlogBaseUrl) !== -1 && response.status === 200) {
+            delete requestMap[response.requestId];
+            return;
+        }
+        // push an empty network event to the buffer to ensure that we have a token available
+        const networkEvent = {};
+        const wasAccepted = buffer.push(networkEvent);
+        if (!wasAccepted) {
+            // Token limit reached, remove request from request map
+            delete requestMap[response.requestId];
+            return;
+        }
+        globalPendo._.extend(networkEvent, createNetworkEvent({
+            request,
+            response
+        }));
+        if (!isPtmPaused) {
+            pluginAPI.Events.eventCaptured.trigger(networkEvent);
+        }
+        delete requestMap[response.requestId];
+    }
+    function handleError({ error, context }) {
+        if (error.requestId && requestMap[error.requestId]) {
+            delete requestMap[error.requestId];
+        }
+        if (context.indexOf('fetch') !== -1) {
+            pluginAPI.log.debug('[NetworkCapture] Fetch tracking failed:', error);
+        }
+        if (context.indexOf('xhr') !== -1) {
+            pluginAPI.log.debug('[NetworkCapture] XHR tracking failed:', error);
+        }
+    }
+    function extractHeaders(headers, allowedHeaders) {
+        const { keys, reduce } = globalPendo._;
+        if (!headers || !allowedHeaders)
+            return [];
+        return reduce(keys(headers), (acc, key) => {
+            const normalizedKey = key.toLowerCase();
+            if (allowedHeaders[normalizedKey]) {
+                acc.push(`${key}: ${headers[key]}`);
+            }
+            return acc;
+        }, []);
+    }
+    function processBody(body, contentType) {
+        if (!body || typeof body !== 'string')
+            return '';
+        const processedBody = maskSensitiveFields({ string: body, contentType, _: globalPendo._ });
+        return truncate(processedBody, true);
+    }
+    function processRequestBody({ request }) {
+        if (!request || !request.body || !requestBodyCb)
+            return '';
+        try {
+            const body = requestBodyCb(request.body, { request });
+            const contentType = globalPendo._.get(request, 'headers.content-type', '');
+            return processBody(body, contentType);
+        }
+        catch (error) {
+            pluginAPI.log.error('[NetworkCapture] Error processing request body', error);
+            return '[Failed to process request body]';
+        }
+    }
+    function processResponseBody({ response }) {
+        if (!response || !response.body || !responseBodyCb)
+            return '';
+        try {
+            const body = responseBodyCb(response.body, { response });
+            const contentType = globalPendo._.get(response, 'headers.content-type', '');
+            return processBody(body, contentType);
+        }
+        catch (error) {
+            pluginAPI.log.error('[NetworkCapture] Error processing response body', error);
+            return '[Failed to process response body]';
+        }
+    }
+    function createNetworkEvent({ request, response }) {
+        const devLogEnvelope = createDevLogEnvelope(pluginAPI, globalPendo);
+        const requestHeaders = extractHeaders(request.headers, allowedRequestHeaders);
+        const responseHeaders = extractHeaders(response.headers, allowedResponseHeaders);
+        const networkEvent = Object.assign(Object.assign({}, devLogEnvelope), { subType: NETWORK_SUB_TYPE, devLogMethod: request.method, devLogStatusCode: response.status, devLogRequestUrl: request.url, devLogRequestHeaders: requestHeaders, devLogResponseHeaders: responseHeaders, devLogCount: 1 });
+        if (requestBodyCb) {
+            networkEvent.devLogRequestBody = processRequestBody({ request });
+        }
+        if (responseBodyCb) {
+            networkEvent.devLogResponseBody = processResponseBody({ response });
+        }
+        return networkEvent;
+    }
+    function send({ unload = false, hidden = false } = {}) {
+        if (!buffer || buffer.isEmpty())
+            return;
+        if (!globalPendo.isSendingEvents()) {
+            buffer.clear();
+            return;
+        }
+        const jzb = buffer.pack();
+        const queryParams = {
+            v: globalPendo.VERSION,
+            ct: pluginAPI.util.getNow()
+        };
+        const url = pluginAPI.transmit.buildBaseDataUrl(DEV_LOG_TYPE, globalPendo.apiKey, queryParams);
+        if (unload || hidden) {
+            sendQueue.drain([{ url, jzb }], unload);
+        }
+        else {
+            sendQueue.push({ url, jzb });
+        }
+    }
+}
+
+export { ConsoleCapture, Feedback, GuideMarkdown, NetworkCapture, createReplayPlugin as Replay, TextCapture, VocPortal, loadAgent };