@agent-native/core 0.202.0-nightly-20261006153106 → 0.202.0

package/dist/automation/index.d.ts

@@ -139,8 +139,8 @@ export declare function createAutomationCallbackHandler(runtime: AutomationRunti
     duplicate?: undefined;
     eventId?: undefined;
 } | {
+    error?: undefined;
     accepted: boolean;
     duplicate: boolean;
     eventId: string;
-    error?: undefined;
 }>;

package/dist/client/analytics.d.ts

@@ -53,6 +53,7 @@ export type ConfigureTrackingOptions = {
     llmConnectionStatus?: boolean;
     authSessionRefresh?: boolean;
     pageviewTracking?: boolean;
+    webVitals?: boolean;
     sessionReplay?: boolean | SessionReplayOptions;
     errorCapture?: boolean | ErrorCaptureConfigOptions;
 };

package/dist/client/analytics.js

@@ -1,5 +1,5 @@
 import { recordTrackingEvent } from "../observability/tracing.js";
-import { AGENT_NATIVE_LIFECYCLE_EVENTS, AGENT_SIGNALS_PAGEVIEW_PROPERTY, AGENT_SIGNALS_VERSION, canonicalTrackingEvent, legacyLifecycleEvent, normalizeTrackingDimension, PAGE_LOAD_PAGEVIEW_PROPERTY, withCanonicalTrackingProperties, } from "../shared/analytics-events.js";
+import { AGENT_NATIVE_LIFECYCLE_EVENTS, AGENT_SIGNALS_PAGEVIEW_PROPERTY, AGENT_SIGNALS_VERSION, canonicalTrackingEvent, legacyLifecycleEvent, normalizeTrackingDimension, PAGE_LOAD_PAGEVIEW_PROPERTY, isWaitedActionResponse, SLOW_ACTION_RESPONSE_MS, withCanonicalTrackingProperties, } from "../shared/analytics-events.js";
 import { ANALYTICS_CLIENT_PLATFORM_PROPERTY, } from "../shared/analytics-platform.js";
 import { hasAttributionSource } from "../shared/attribution-source.js";
 import { resolveLaneEndpoint } from "../shared/environment-lanes.js";
@@ -18,7 +18,9 @@ import { scheduleAfterPaint } from "./use-after-paint.js";
 export { clearAnalyticsSessionId, setAnalyticsSessionId, } from "./analytics-session.js";
 import { fetchAgentEngineStatus, fetchAuthSessionStatus, } from "./client-status-requests.js";
 import { firstPartyHosts, installErrorCapture, } from "./error-capture.js";
+import { currentRouteTemplate } from "./route-template.js";
 import { scrubUrl } from "./url-scrub.js";
+import { installWebVitals, } from "./web-vitals.js";
 export { scrubUrl } from "./url-scrub.js";
 export { addErrorBreadcrumb, captureException, captureMessage, isErrorCaptureInstalled, } from "./error-capture.js";
 export { getSessionReplayContext, getSessionReplayUrl, } from "./session-replay-context.js";
@@ -1105,6 +1107,8 @@ export function configureTracking(options) {
         }
         if (options.pageviewTracking !== false) {
             installPageviewTracking();
+            if (options.webVitals !== false)
+                installWebVitalsTracking();
         }
         maybeInstallSessionReplay(options.sessionReplay, {
             endpoint: options.endpoint,
@@ -1570,6 +1574,11 @@ function inferTemplateName(properties) {
     }
     return app;
 }
+/**
+ * Events that name their page only by route template. A path can hold a slug
+ * or an email, so it never rides along, not even from an app's default props.
+ */
+const ROUTE_ONLY_EVENT_NAMES = new Set(["web_vitals"]);
 function resolveProps(name, params) {
     if (name === "session_replay_started") {
         return params?.recording_attempt_id === undefined
@@ -1625,13 +1634,18 @@ function resolveProps(name, params) {
     });
     const withIdentity = applyTrackingIdentity(standard);
     const identity = _trackingIdentity;
-    return {
+    const resolved = {
         ...withIdentity,
         ...(getTrackingUserId() ? { user_id: getTrackingUserId() } : {}),
         ...(identity?.userEmail ? { user_email: identity.userEmail } : {}),
         ...(identity?.orgId ? { workspace_id: identity.orgId } : {}),
         [ANALYTICS_CLIENT_PLATFORM_PROPERTY]: getAnalyticsClientPlatform(_configuredAnalyticsClientPlatform ?? undefined),
     };
+    if (ROUTE_ONLY_EVENT_NAMES.has(name)) {
+        delete resolved.url;
+        delete resolved.path;
+    }
+    return resolved;
 }
 function sessionReplayTrackingProperties() {
     const module = _sessionReplayModuleForCapture;
@@ -1831,20 +1845,54 @@ function installPageviewTracking() {
     window.history.pushState = function pushState(...args) {
         const result = originalPushState.apply(this, args);
         syncTrackingContentCaptureForLocation();
+        state.webVitals?.navigate("push");
         schedulePageview("pushState");
         return result;
     };
     window.history.replaceState = function replaceState(...args) {
         const result = originalReplaceState.apply(this, args);
         syncTrackingContentCaptureForLocation();
+        state.webVitals?.navigate("replace");
         schedulePageview("replaceState");
         return result;
     };
     window.addEventListener("popstate", () => {
         syncTrackingContentCaptureForLocation();
+        state.webVitals?.navigate("push");
         schedulePageview("popstate");
     });
 }
+function webVitalsLocation() {
+    return {
+        route: currentRouteTemplate(),
+        pathname: window.location.pathname,
+    };
+}
+function reportPageViewVitals(vitals) {
+    _sessionReplayModuleForCapture?.emitSessionReplayWebVitals?.(vitals);
+    trackEvent("web_vitals", {
+        ...(vitals.route ? { route: vitals.route } : {}),
+        navigation_type: vitals.navigationType,
+        ttfb_ms: vitals.ttfbMs,
+        lcp_ms: vitals.lcpMs,
+        inp_ms: vitals.inpMs,
+        cls: vitals.cls,
+    });
+}
+function installWebVitalsTracking() {
+    const state = getPageviewTrackingState();
+    if (state.webVitalsInstalled)
+        return;
+    state.webVitalsInstalled = true;
+    if (isLocalAnalyticsHostname(window.location.hostname))
+        return;
+    try {
+        state.webVitals = installWebVitals(webVitalsLocation, reportPageViewVitals);
+    }
+    catch (error) {
+        console.warn("[analytics] Web Vitals capture is unavailable:", error);
+    }
+}
 function sendAgentNativeAnalytics(name, properties) {
     if (isSyntheticBrowserTraffic())
         return;
@@ -1912,13 +1960,20 @@ const REPLAY_UNMARKED_EVENT_NAMES = new Set([
     "session status",
     "session_status",
     "action.response",
+    "web_vitals",
     "agent_chat_lifecycle",
     "session_replay_started",
     "session replay upload rejected",
     "session_replay_upload_rejected",
     AGENT_NATIVE_EXCEPTION_EVENT_NAME,
 ]);
-function markTrackedEventInSessionReplay(name) {
+function markTrackedEventInSessionReplay(name, props) {
+    if (name === "action.response" &&
+        typeof props.duration_ms === "number" &&
+        props.duration_ms >= SLOW_ACTION_RESPONSE_MS &&
+        isWaitedActionResponse(props)) {
+        _sessionReplayModuleForCapture?.emitSessionReplaySlowRequest?.(props);
+    }
     if (REPLAY_UNMARKED_EVENT_NAMES.has(name))
         return;
     _sessionReplayModuleForCapture?.emitSessionReplayAnalyticsEvent?.(name);
@@ -1945,8 +2000,9 @@ function trackBrowserEvent(name, params, markInReplay) {
             sendGtag: !gtagNameMatchesCanonical,
         });
     }
-    if (markInReplay)
-        markTrackedEventInSessionReplay(canonical?.name ?? name);
+    if (markInReplay) {
+        markTrackedEventInSessionReplay(canonical?.name ?? name, props);
+    }
     void recordTrackingEvent(name, props, "client");
     const lifecycle = legacyLifecycleEvent(name, props);
     // The alias describes the same moment, so it gets no second replay marker.

package/dist/client/route-template.d.ts

@@ -0,0 +1,16 @@
+type ManifestRoute = {
+    id: string;
+    parentId?: string;
+    path?: string;
+    index?: boolean;
+};
+/**
+ * The route template a path renders, such as `/sessions/:id`, so telemetry
+ * groups pages without carrying ids from the URL. Null when no manifest route
+ * matches: a raw path keeps slugs, short ids, and emails, so telemetry omits
+ * the route instead.
+ */
+export declare function routeTemplateForPath(pathname: string, routes: Record<string, ManifestRoute> | undefined, basename?: string): string | null;
+/** Browser only: the route template of the current location, if any. */
+export declare function currentRouteTemplate(): string | null;
+export {};

package/dist/client/route-template.js

@@ -0,0 +1,127 @@
+const MAX_ROUTE_TEMPLATE_LENGTH = 200;
+const PARAM_SEGMENT = /^:[\w-]+$/;
+let cachedRoutes;
+let cachedRouteCount = 0;
+let cachedPatterns = [];
+// Mirrors React Router's branch ranking so the template is the route that
+// rendered, without importing react-router (an optional peer of core).
+function scorePattern(segments, index) {
+    let score = segments.length;
+    if (segments.includes("*"))
+        score -= 2;
+    if (index)
+        score += 2;
+    for (const segment of segments) {
+        if (segment === "*")
+            continue;
+        score += PARAM_SEGMENT.test(segment) ? 3 : segment === "" ? 1 : 10;
+    }
+    return score;
+}
+function explodeOptionalSegments(segments) {
+    if (!segments.length)
+        return [[]];
+    const [first, ...rest] = segments;
+    const tails = explodeOptionalSegments(rest);
+    if (!first.endsWith("?"))
+        return tails.map((tail) => [first, ...tail]);
+    const required = first.slice(0, -1);
+    return [...tails.map((tail) => [required, ...tail]), ...tails];
+}
+function fullPathSegments(route, routes) {
+    const chain = [];
+    const seen = new Set();
+    let current = route;
+    while (current && !seen.has(current.id)) {
+        seen.add(current.id);
+        if (current.path)
+            chain.unshift(current.path);
+        current = current.parentId ? routes[current.parentId] : undefined;
+    }
+    return chain
+        .join("/")
+        .split("/")
+        .filter((segment) => segment !== "");
+}
+// React Router lazy route discovery adds routes to the same manifest object,
+// so the same object with more routes is a new manifest.
+function routePatterns(routes) {
+    const manifestRoutes = Object.values(routes);
+    if (routes === cachedRoutes && manifestRoutes.length === cachedRouteCount) {
+        return cachedPatterns;
+    }
+    const patterns = [];
+    for (const route of manifestRoutes) {
+        if (route.path == null && !route.index)
+            continue;
+        for (const segments of explodeOptionalSegments(fullPathSegments(route, routes))) {
+            patterns.push({
+                segments,
+                score: scorePattern(segments, Boolean(route.index)),
+            });
+        }
+    }
+    patterns.sort((a, b) => b.score - a.score);
+    cachedRoutes = routes;
+    cachedRouteCount = manifestRoutes.length;
+    cachedPatterns = patterns;
+    return patterns;
+}
+function matches(pattern, pathSegments) {
+    for (let index = 0; index < pattern.length; index += 1) {
+        const segment = pattern[index];
+        if (segment === "*")
+            return true;
+        const value = pathSegments[index];
+        if (value === undefined)
+            return false;
+        if (PARAM_SEGMENT.test(segment))
+            continue;
+        if (segment.toLowerCase() !== value.toLowerCase())
+            return false;
+    }
+    return pattern.length === pathSegments.length;
+}
+function stripBasename(pathname, basename) {
+    const base = basename.replace(/\/+$/, "");
+    if (!base)
+        return pathname;
+    const lower = pathname.toLowerCase();
+    const lowerBase = base.toLowerCase();
+    if (lower === lowerBase)
+        return "/";
+    return lower.startsWith(`${lowerBase}/`) ? pathname.slice(base.length) : null;
+}
+function decodeSegment(segment) {
+    try {
+        return decodeURIComponent(segment);
+    }
+    catch {
+        return segment;
+    }
+}
+/**
+ * The route template a path renders, such as `/sessions/:id`, so telemetry
+ * groups pages without carrying ids from the URL. Null when no manifest route
+ * matches: a raw path keeps slugs, short ids, and emails, so telemetry omits
+ * the route instead.
+ */
+export function routeTemplateForPath(pathname, routes, basename = "") {
+    const relative = stripBasename(pathname, basename);
+    if (!routes || relative === null)
+        return null;
+    const pathSegments = relative
+        .split("/")
+        .filter((segment) => segment !== "")
+        .map(decodeSegment);
+    const match = routePatterns(routes).find((pattern) => matches(pattern.segments, pathSegments));
+    return match
+        ? `/${match.segments.join("/")}`.slice(0, MAX_ROUTE_TEMPLATE_LENGTH)
+        : null;
+}
+/** Browser only: the route template of the current location, if any. */
+export function currentRouteTemplate() {
+    const routes = window.__reactRouterManifest?.routes;
+    const basename = window.__reactRouterContext?.basename;
+    return routeTemplateForPath(window.location.pathname, routes, basename ?? "");
+}

package/dist/client/session-replay.d.ts

@@ -72,6 +72,8 @@ export declare const SESSION_REPLAY_CONSOLE_EVENT_TAG = "agent-native.console";
 export declare const SESSION_REPLAY_NETWORK_EVENT_TAG = "agent-native.network";
 export declare const SESSION_REPLAY_AGENT_CHAT_EVENT_TAG = "agent-native.chat";
 export declare const SESSION_REPLAY_ANALYTICS_EVENT_TAG = "agent-native.event";
+export declare const SESSION_REPLAY_VITALS_EVENT_TAG = "agent-native.vitals";
+export declare const SESSION_REPLAY_SLOW_REQUEST_EVENT_TAG = "agent-native.slow_request";
 export declare function getSessionReplaySamplingScore(sessionId: string, salt?: string): number;
 export declare function shouldSampleSessionReplay(sessionId: string, sampleRate?: number, salt?: string): boolean;
 export declare function flushSessionReplay(reason?: string): Promise<void>;
@@ -94,6 +96,34 @@ export declare function emitSessionReplayException(input: {
  * is recorded; event properties stay out of the replay.
  */
 export declare function emitSessionReplayAnalyticsEvent(name: string): void;
+export type SessionReplaySlowRequest = {
+    action?: unknown;
+    method?: unknown;
+    duration_ms?: unknown;
+    status_code?: unknown;
+    outcome?: unknown;
+    page_hidden?: unknown;
+};
+/**
+ * Mark a slow `action.response` on the replay timeline with that event's own
+ * timing, which runs to the end of the body; a network event stops at the
+ * headers. Only these operational fields are recorded, and the marker shares
+ * the analytics marker budget.
+ */
+export declare function emitSessionReplaySlowRequest(input: SessionReplaySlowRequest): void;
+export type SessionReplayWebVitals = {
+    route?: string;
+    navigationType: string;
+    ttfbMs?: number;
+    lcpMs?: number;
+    inpMs?: number;
+    cls?: number;
+};
+/**
+ * Mark a finished page view's Web Vitals on the replay timeline. Shares the
+ * analytics marker budget, since each page view adds one.
+ */
+export declare function emitSessionReplayWebVitals(input: SessionReplayWebVitals): void;
 export type SessionReplayAgentChatEvent = {
     phase: "surface-mounted" | "run-observed" | "run-stopped";
     surface: string | number;

package/dist/client/session-replay.js

@@ -72,6 +72,8 @@ export const SESSION_REPLAY_CONSOLE_EVENT_TAG = "agent-native.console";
 export const SESSION_REPLAY_NETWORK_EVENT_TAG = "agent-native.network";
 export const SESSION_REPLAY_AGENT_CHAT_EVENT_TAG = "agent-native.chat";
 export const SESSION_REPLAY_ANALYTICS_EVENT_TAG = "agent-native.event";
+export const SESSION_REPLAY_VITALS_EVENT_TAG = "agent-native.vitals";
+export const SESSION_REPLAY_SLOW_REQUEST_EVENT_TAG = "agent-native.slow_request";
 const SESSION_REPLAY_LIFECYCLE_EVENT_TAG = "agent-native.session_replay";
 const DEFAULT_MAX_CONSOLE_EVENTS = 1000;
 const DEFAULT_MAX_NETWORK_EVENTS = 2000;
@@ -2190,6 +2192,23 @@ function installNetworkCapture(state, captureOptions) {
         ? (captureOptions.maxErrorBodyLength ?? DEFAULT_MAX_ERROR_BODY_LENGTH)
         : null;
     const restores = [];
+    // A background tab throttles timers, so a request that was ever hidden did
+    // not keep anyone waiting for its duration. Checking visibility only at the
+    // end misses a tab that was hidden and came back.
+    let hiddenEpoch = 0;
+    const countHidden = () => {
+        if (document.visibilityState === "hidden")
+            hiddenEpoch += 1;
+    };
+    document.addEventListener("visibilitychange", countHidden);
+    restores.push(() => document.removeEventListener("visibilitychange", countHidden));
+    const watchHidden = () => {
+        const hiddenAtStart = document.visibilityState !== "visible";
+        const epochAtStart = hiddenEpoch;
+        return () => hiddenAtStart ||
+            epochAtStart !== hiddenEpoch ||
+            document.visibilityState !== "visible";
+    };
     // A request the browser cancels because the page is leaving fails exactly
     // like a network error. WebKit cancels right after beforeunload, Chromium
     // after pagehide; neither listener costs the page its bfcache eligibility.
@@ -2217,7 +2236,7 @@ function installNetworkCapture(state, captureOptions) {
             target.removeEventListener(type, listener, { capture: true });
         }
     });
-    const recordRequest = (api, method, rawUrl, status, ok, durationMs, error, responseBody) => {
+    const recordRequest = (api, method, rawUrl, status, ok, durationMs, pageHidden, error, responseBody) => {
         if (stopped)
             return;
         try {
@@ -2232,6 +2251,7 @@ function installNetworkCapture(state, captureOptions) {
                 status,
                 ok,
                 durationMs: Math.max(0, Math.round(durationMs)),
+                ...(pageHidden ? { pageHidden: true } : {}),
                 ...(status === 0 && pageLeaving ? { pageLeaving: true } : {}),
                 ...(error
                     ? {
@@ -2299,6 +2319,7 @@ function installNetworkCapture(state, captureOptions) {
                 return originalFetch.call(self, input, init);
             }
             const startedAt = performance.now();
+            const wasHidden = watchHidden();
             const result = originalFetch.call(self, input, init);
             if (!result || typeof result.then !== "function") {
                 return result;
@@ -2306,6 +2327,7 @@ function installNetworkCapture(state, captureOptions) {
             return result.then((response) => {
                 try {
                     const durationMs = performance.now() - startedAt;
+                    const pageHidden = wasHidden();
                     if (errorBodyCap !== null && response.status >= 500) {
                         let clone = null;
                         try {
@@ -2321,18 +2343,18 @@ function installNetworkCapture(state, captureOptions) {
                             });
                             Promise.race([bodyPromise, timeoutPromise])
                                 .then((responseBody) => {
-                                recordRequest("fetch", method, url, response.status, response.ok, durationMs, undefined, responseBody);
+                                recordRequest("fetch", method, url, response.status, response.ok, durationMs, pageHidden, undefined, responseBody);
                             })
                                 .catch(() => {
                                 // never affect the caller
                             });
                         }
                         else {
-                            recordRequest("fetch", method, url, response.status, response.ok, durationMs);
+                            recordRequest("fetch", method, url, response.status, response.ok, durationMs, pageHidden);
                         }
                     }
                     else {
-                        recordRequest("fetch", method, url, response.status, response.ok, durationMs);
+                        recordRequest("fetch", method, url, response.status, response.ok, durationMs, pageHidden);
                     }
                 }
                 catch {
@@ -2341,7 +2363,7 @@ function installNetworkCapture(state, captureOptions) {
                 return response;
             }, (error) => {
                 try {
-                    recordRequest("fetch", method, url, 0, false, performance.now() - startedAt, error instanceof Error ? error.message : String(error));
+                    recordRequest("fetch", method, url, 0, false, performance.now() - startedAt, wasHidden(), error instanceof Error ? error.message : String(error));
                 }
                 catch {
                     // never affect the caller
@@ -2374,6 +2396,7 @@ function installNetworkCapture(state, captureOptions) {
                 const info = xhrInfo.get(this);
                 if (info && !stopped && !replayCaptureInternal) {
                     const startedAt = performance.now();
+                    const wasHidden = watchHidden();
                     let errorMessage;
                     const markError = (message) => () => {
                         errorMessage = message;
@@ -2392,7 +2415,7 @@ function installNetworkCapture(state, captureOptions) {
                         if (errorBodyCap !== null && !errorMessage && status >= 500) {
                             responseBody = readXhrErrorBody(this, errorBodyCap);
                         }
-                        recordRequest("xhr", info.method, info.url, effectiveStatus, !errorMessage && status >= 200 && status < 300, performance.now() - startedAt, errorMessage, responseBody);
+                        recordRequest("xhr", info.method, info.url, effectiveStatus, !errorMessage && status >= 200 && status < 300, performance.now() - startedAt, wasHidden(), errorMessage, responseBody);
                         xhrInfo.delete(this);
                     }, { once: true });
                 }
@@ -2821,6 +2844,20 @@ export function emitSessionReplayException(input) {
         ...(input.url ? { url: input.url } : {}),
     });
 }
+function reserveAnalyticsMarker(state) {
+    if (state.analyticsEventCount >= MAX_ANALYTICS_EVENTS_PER_REPLAY) {
+        return false;
+    }
+    state.analyticsEventCount += 1;
+    const stored = readStoredReplaySession();
+    if (stored?.replayId === state.replayId) {
+        writeStoredReplaySession({
+            ...stored,
+            analyticsEventCount: state.analyticsEventCount,
+        });
+    }
+    return true;
+}
 /**
  * Mark a tracked analytics event on the replay timeline. Only the event name
  * is recorded; event properties stay out of the replay.
@@ -2829,23 +2866,64 @@ export function emitSessionReplayAnalyticsEvent(name) {
     const state = getState();
     if (!state.active || !state.addCustomEvent)
         return;
-    if (state.analyticsEventCount >= MAX_ANALYTICS_EVENTS_PER_REPLAY)
-        return;
     const bounded = name.trim().slice(0, MAX_ANALYTICS_EVENT_NAME_LENGTH);
-    if (!bounded)
+    if (!bounded || !reserveAnalyticsMarker(state))
         return;
-    state.analyticsEventCount += 1;
-    const stored = readStoredReplaySession();
-    if (stored?.replayId === state.replayId) {
-        writeStoredReplaySession({
-            ...stored,
-            analyticsEventCount: state.analyticsEventCount,
-        });
-    }
     emitReplayCustomEvent(state, SESSION_REPLAY_ANALYTICS_EVENT_TAG, {
         name: bounded,
     });
 }
+/**
+ * Mark a slow `action.response` on the replay timeline with that event's own
+ * timing, which runs to the end of the body; a network event stops at the
+ * headers. Only these operational fields are recorded, and the marker shares
+ * the analytics marker budget.
+ */
+export function emitSessionReplaySlowRequest(input) {
+    const state = getState();
+    if (!state.active || !state.addCustomEvent)
+        return;
+    if (typeof input.duration_ms !== "number")
+        return;
+    if (!reserveAnalyticsMarker(state))
+        return;
+    emitReplayCustomEvent(state, SESSION_REPLAY_SLOW_REQUEST_EVENT_TAG, {
+        ...(typeof input.action === "string"
+            ? { action: input.action.slice(0, MAX_ANALYTICS_EVENT_NAME_LENGTH) }
+            : {}),
+        ...(typeof input.method === "string"
+            ? { method: input.method.slice(0, 10) }
+            : {}),
+        duration_ms: input.duration_ms,
+        ...(typeof input.status_code === "number"
+            ? { status_code: input.status_code }
+            : {}),
+        ...(typeof input.outcome === "string"
+            ? { outcome: input.outcome.slice(0, 20) }
+            : {}),
+        page_hidden: input.page_hidden === true,
+    });
+}
+/**
+ * Mark a finished page view's Web Vitals on the replay timeline. Shares the
+ * analytics marker budget, since each page view adds one.
+ */
+export function emitSessionReplayWebVitals(input) {
+    const state = getState();
+    if (!state.active || !state.addCustomEvent)
+        return;
+    if (!reserveAnalyticsMarker(state))
+        return;
+    const metric = (value) => typeof value === "number" && Number.isFinite(value) ? value : undefined;
+    emitReplayCustomEvent(state, SESSION_REPLAY_VITALS_EVENT_TAG, {
+        ...(input.route ? { route: input.route.slice(0, 200) } : {}),
+        navigationType: input.navigationType.slice(0, 20),
+        ...(metric(input.ttfbMs) !== undefined ? { ttfbMs: input.ttfbMs } : {}),
+        ...(metric(input.lcpMs) !== undefined ? { lcpMs: input.lcpMs } : {}),
+        ...(metric(input.inpMs) !== undefined ? { inpMs: input.inpMs } : {}),
+        ...(metric(input.cls) !== undefined ? { cls: input.cls } : {}),
+    });
+}
 export function emitSessionReplayAgentChatEvent(input) {
     const state = getState();
     if (!state.active || !state.addCustomEvent)

package/dist/client/use-action.js

@@ -1,4 +1,5 @@
 import { hashKey, useQuery, useMutation, useQueryClient, } from "@tanstack/react-query";
+import { SLOW_ACTION_RESPONSE_MS } from "../shared/analytics-events.js";
 import { ANALYTICS_CLIENT_PLATFORM_HEADER } from "../shared/analytics-platform.js";
 import { actionCircuitRemainingMs, actionErrorCode, actionErrorRetryAfterMs, actionErrorStatus, assertActionCircuitClosed, endsActionPolling, isActionCircuitOpenError, isTerminalActionError, recordActionFailure, resetActionFailureCircuit, resetActionFailureCircuits, } from "./action-failure-circuit.js";
 import { getAnalyticsClientPlatform } from "./analytics-platform.js";
@@ -9,6 +10,7 @@ import { agentNativeApiDisabledReason, assertAgentNativeApiEnabled, } from "./ap
 import { getBrowserTabId } from "./browser-tab-id.js";
 import { clientBuildId, clientCompatibilityVersion, reloadForClientCompatibilityMismatch, } from "./build-compatibility.js";
 import { ensureEmbedAuthFetchInterceptor } from "./embed-auth.js";
+import { currentRouteTemplate } from "./route-template.js";
 import { recheckSessionAfterUnauthorized } from "./use-session.js";
 function actionPrefix() {
     return agentNativePath("/_agent-native/actions");
@@ -427,8 +429,19 @@ function parseServerTiming(response) {
     }
     return timings;
 }
+function actionTelemetryRoute() {
+    if (typeof window === "undefined")
+        return undefined;
+    try {
+        return currentRouteTemplate() ?? undefined;
+    }
+    catch {
+        // coercion-ok: telemetry never changes the action; the event omits route.
+        return undefined;
+    }
+}
 function getActionResponseSampling(error, durationMs, response) {
-    if (error || durationMs >= 1_000) {
+    if (error || durationMs >= SLOW_ACTION_RESPONSE_MS) {
         return { track: true, sampleRate: 1, sampled: false };
     }
     if (response && response.status >= 400 && response.status < 500) {
@@ -446,6 +459,7 @@ function getActionResponseSampling(error, durationMs, response) {
 async function actionFetch(name, method, params, options) {
     assertAgentNativeApiEnabled(`${method} ${name}`);
     const startedAt = actionTelemetryNow();
+    const routeAtStart = actionTelemetryRoute();
     const hiddenEpochAtStart = pageHiddenEpoch;
     const hiddenAtStart = typeof document !== "undefined" && document.visibilityState !== "visible";
     const timeoutMs = options?.timeoutMs ?? DEFAULT_ACTION_TIMEOUT_MS;
@@ -492,6 +506,7 @@ async function actionFetch(name, method, params, options) {
                     request_id: response?.headers.get("x-agent-native-request-id") ?? undefined,
                     action: name,
                     method,
+                    route: routeAtStart,
                     sample_rate: sampling.sampleRate,
                     sample_weight: 1 / sampling.sampleRate,
                     sampled: sampling.sampled,