@agent-native/core 0.133.3 → 0.134.1

package/src/server/error-noise-filter.ts

@@ -0,0 +1,268 @@
+/**
+ * Provider-agnostic drop rules for server error reporting.
+ *
+ * These rules were tuned against real production volume while Sentry was the
+ * only backend, and they lived inside its `beforeSend`. They are not Sentry
+ * policy — they describe which server errors are non-bugs in *this* framework
+ * (expected 4xx, access-control rejections, Lambda freeze/thaw socket noise).
+ * Any second backend that skips them receives a firehose rather than a signal:
+ * the `socket hang up` rule alone accounts for ~10k events/day.
+ *
+ * The rules operate on a normalized signal so the same predicate can judge a
+ * Sentry `Event` (already parsed by the SDK) and a raw `Error` reaching the
+ * PostHog provider. Fields a given source cannot supply stay `undefined`, and
+ * every rule requires the evidence it depends on — an unknown never reads as
+ * a match.
+ */
+
+import { parseStackFrames } from "../tracking/posthog-exception.js";
+
+export interface ErrorSignalFrame {
+  function?: string;
+  filename?: string;
+  in_app?: boolean;
+}
+
+export interface NormalizedErrorSignal {
+  /** Error class name, e.g. `ValidationError`. */
+  type?: string;
+  /** Error message. */
+  value?: string;
+  /** Capture mechanism, e.g. `onunhandledrejection`. */
+  mechanismType?: string;
+  frames?: ErrorSignalFrame[];
+  /** HTTP status carried by h3's `HTTPError` / `H3Error`. */
+  statusCode?: number;
+  tags?: Record<string, string | undefined>;
+  /**
+   * Sentry-only: some SDK-internal rejections arrive with no `exception.values`
+   * at all and only a `metadata` blob. Left `undefined` elsewhere.
+   */
+  metadataValue?: string;
+  metadataFilename?: string;
+  hasExceptionValues?: boolean;
+}
+
+function isUnhandledRejection(signal: NormalizedErrorSignal): boolean {
+  return (
+    typeof signal.mechanismType === "string" &&
+    signal.mechanismType.endsWith("onunhandledrejection")
+  );
+}
+
+/** Expected user-input rejections. The framework and CLI both throw these. */
+function isValidationNoise(signal: NormalizedErrorSignal): boolean {
+  return (
+    signal.type === "ValidationError" || signal.tags?.handled === "validation"
+  );
+}
+
+/**
+ * Access-control rejections. These are 4xx user-facing errors that reached the
+ * error hook because a route forgot to catch them — fixing the route is the
+ * right answer, but until then they bury real bugs. Auth routes report their
+ * own failures at `warning` level, so this only sees the escape path.
+ */
+function isAccessControlNoise(signal: NormalizedErrorSignal): boolean {
+  return (
+    signal.type === "ForbiddenError" || signal.type === "UnauthorizedError"
+  );
+}
+
+/**
+ * `socket hang up` unhandled rejections from Lambda freeze cycles. AWS recycles
+ * long-lived sockets (MCP Streamable HTTP long-polls, keep-alive agents) ~60s
+ * after a function returns 200; the next thaw delivers a socket-end event whose
+ * Promise has nobody left to await it. The function already returned correctly,
+ * so there is no user impact. The narrow frame match keeps genuine
+ * application-thrown socket errors visible.
+ */
+function isLambdaSocketHangUpNoise(signal: NormalizedErrorSignal): boolean {
+  if (signal.value !== "socket hang up" || !isUnhandledRejection(signal)) {
+    return false;
+  }
+  return (signal.frames ?? []).some(
+    (frame) =>
+      frame?.function === "Socket.socketOnEnd" ||
+      frame?.filename === "node:_http_client",
+  );
+}
+
+/**
+ * SDK-only `ErrorEvent` promise rejections — typically the Neon serverless
+ * driver's WebSocket dying across a freeze/thaw and rejecting a floating
+ * promise with the raw ErrorEvent (`db/client.ts` already records these with
+ * context). Events with real application frames stay visible.
+ *
+ * "Application frame" must exclude the Sentry SDK's own bundled chunks:
+ * serverless bundles place them under the app root (e.g.
+ * `/var/task/_libs/@sentry/node+….mjs`), outside node_modules, so the SDK marks
+ * them `in_app` and the instrumentation stack alone would defeat this filter.
+ */
+function isSdkErrorEventNoise(signal: NormalizedErrorSignal): boolean {
+  if (signal.value === "[object ErrorEvent]" && isUnhandledRejection(signal)) {
+    const frames = signal.frames ?? [];
+    const hasApplicationFrame = frames.some(
+      (frame) =>
+        frame?.in_app && !String(frame?.filename ?? "").includes("sentry"),
+    );
+    const hasSentryFrame = frames.some((frame) =>
+      String(frame?.filename ?? "").includes("sentry"),
+    );
+    if (!hasApplicationFrame && hasSentryFrame) return true;
+  }
+
+  return (
+    signal.metadataValue === "[object ErrorEvent]" &&
+    signal.hasExceptionValues === false &&
+    String(signal.metadataFilename ?? "").includes("sentry")
+  );
+}
+
+/**
+ * h3's `createError({ statusCode: 4xx })` produces an `HTTPError` (h3 v2) /
+ * `H3Error` (h3 v1). 4xx ones are handler-controlled "expected failure"
+ * responses that route through the error hook only because they bubble out of
+ * `defineEventHandler`. Capture when the status looks 5xx, or is missing on a
+ * generic Error masquerading as an HTTPError.
+ */
+function isExpectedHttpNoise(signal: NormalizedErrorSignal): boolean {
+  if (signal.type !== "HTTPError" && signal.type !== "H3Error") return false;
+
+  const code = signal.statusCode;
+  if (typeof code === "number" && Number.isFinite(code)) {
+    return code >= 400 && code < 500;
+  }
+
+  // No status in the payload — match the common 4xx messages so handler-thrown
+  // 404/400/403/401 don't pollute the backend. A heuristic, but the
+  // alternatives (every 4xx becomes a real issue, or every route grows a
+  // catch+return) are worse.
+  const value = signal.value ?? "";
+  return (
+    /^Cannot find any route matching/i.test(value) ||
+    / not found$/i.test(value) ||
+    /Unauthenticated$/i.test(value) ||
+    /^Unauthorized$/i.test(value) ||
+    /^No access to /i.test(value)
+  );
+}
+
+/**
+ * `false` when the error is known non-bug noise and should not be reported.
+ *
+ * Deliberately fails open: anything the rules cannot positively identify as
+ * noise is reported. A dropped real error is invisible; a kept noisy one is
+ * merely loud.
+ */
+export function shouldReportErrorSignal(
+  signal: NormalizedErrorSignal,
+): boolean {
+  return !(
+    isValidationNoise(signal) ||
+    isAccessControlNoise(signal) ||
+    isLambdaSocketHangUpNoise(signal) ||
+    isSdkErrorEventNoise(signal) ||
+    isExpectedHttpNoise(signal)
+  );
+}
+
+interface SentryLikeEvent {
+  exception?: {
+    values?: Array<{
+      type?: string;
+      value?: string;
+      mechanism?: { type?: string };
+      stacktrace?: { frames?: ErrorSignalFrame[] };
+    }>;
+  };
+  tags?: Record<string, unknown>;
+  contexts?: Record<string, Record<string, unknown> | undefined>;
+  metadata?: { value?: unknown; filename?: unknown };
+}
+
+function toNumericStatus(value: unknown): number | undefined {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string") {
+    const parsed = parseInt(value, 10);
+    if (Number.isFinite(parsed)) return parsed;
+  }
+  return undefined;
+}
+
+/** Normalize a Sentry event. Typed structurally so this module stays SDK-free. */
+export function errorSignalFromSentryEvent(
+  event: SentryLikeEvent,
+): NormalizedErrorSignal {
+  const first = event.exception?.values?.[0];
+  const tags: Record<string, string | undefined> = {};
+  for (const [key, value] of Object.entries(event.tags ?? {})) {
+    if (typeof value === "string") tags[key] = value;
+  }
+
+  return {
+    type: first?.type,
+    value: first?.value ?? "",
+    mechanismType: first?.mechanism?.type,
+    frames: first?.stacktrace?.frames ?? [],
+    statusCode: toNumericStatus(
+      event.tags?.statusCode ?? event.contexts?.h3?.statusCode,
+    ),
+    tags,
+    metadataValue:
+      typeof event.metadata?.value === "string"
+        ? event.metadata.value
+        : undefined,
+    metadataFilename:
+      typeof event.metadata?.filename === "string"
+        ? event.metadata.filename
+        : undefined,
+    hasExceptionValues: Boolean(event.exception?.values?.length),
+  };
+}
+
+export interface ErrorSignalFromErrorOptions {
+  mechanismType?: string;
+  tags?: Record<string, string | undefined>;
+}
+
+/** Normalize a raw thrown value for backends that never see a Sentry event. */
+export function errorSignalFromError(
+  error: unknown,
+  options: ErrorSignalFromErrorOptions = {},
+): NormalizedErrorSignal {
+  if (!(error instanceof Error)) {
+    return {
+      type: "Error",
+      value: typeof error === "string" ? error : String(error ?? ""),
+      mechanismType: options.mechanismType,
+      tags: options.tags,
+      hasExceptionValues: true,
+    };
+  }
+
+  const withStatus = error as Error & {
+    statusCode?: unknown;
+    status?: unknown;
+  };
+
+  return {
+    type: error.name || "Error",
+    value: error.message ?? "",
+    mechanismType: options.mechanismType,
+    frames: parseStackFrames(error.stack),
+    statusCode:
+      toNumericStatus(withStatus.statusCode) ??
+      toNumericStatus(withStatus.status),
+    tags: options.tags,
+    hasExceptionValues: true,
+  };
+}
+
+/** Convenience wrapper for the raw-error path. */
+export function shouldReportError(
+  error: unknown,
+  options: ErrorSignalFromErrorOptions = {},
+): boolean {
+  return shouldReportErrorSignal(errorSignalFromError(error, options));
+}

package/src/server/posthog-config.ts

@@ -0,0 +1,75 @@
+/**
+ * Public PostHog config for the browser.
+ *
+ * PostHog project API keys are publishable — that is how `posthog-js` ships in
+ * every customer's bundle — so this mirrors how the Sentry client DSN already
+ * reaches the browser: env-derived, identical for every visitor, and therefore
+ * safe inside the CDN-cached SSR shell (see `guard:ssr-cache-shell`).
+ *
+ * The browser sends exceptions straight to PostHog rather than relaying them
+ * through `/_agent-native/track`: that route requires a resolved session by
+ * design, so relaying would silently drop every signed-out crash — exactly the
+ * class of failure that looks like "no errors" instead of "no reporting".
+ */
+
+const POSTHOG_DEFAULT_HOST = "https://us.i.posthog.com";
+
+function firstNonEmpty(
+  ...values: Array<string | undefined>
+): string | undefined {
+  for (const value of values) {
+    const trimmed = value?.trim();
+    if (trimmed) return trimmed;
+  }
+  return undefined;
+}
+
+export interface PublicPostHogConfig {
+  posthogKey: string;
+  posthogHost: string;
+  posthogErrorTracking: boolean;
+}
+
+/**
+ * Resolve the browser-facing PostHog config, or `undefined` when none is set.
+ *
+ * Note this deliberately does NOT fall back to `POSTHOG_API_KEY`: a
+ * server-only personal/private key must never be inlined into the public HTML
+ * shell. Operators opt into browser capture by setting a public key explicitly.
+ */
+export function resolvePublicPostHogConfig(): PublicPostHogConfig | undefined {
+  const posthogKey = firstNonEmpty(
+    process.env.POSTHOG_PUBLIC_KEY,
+    process.env.VITE_POSTHOG_KEY,
+    process.env.VITE_POSTHOG_PUBLIC_KEY,
+  );
+  if (!posthogKey) return undefined;
+
+  const posthogHost = (
+    firstNonEmpty(
+      process.env.POSTHOG_PUBLIC_HOST,
+      process.env.VITE_POSTHOG_HOST,
+      process.env.POSTHOG_HOST,
+    ) ?? POSTHOG_DEFAULT_HOST
+  ).replace(/\/+$/, "");
+
+  return {
+    posthogKey,
+    posthogHost,
+    posthogErrorTracking:
+      process.env.POSTHOG_ERROR_TRACKING?.trim().toLowerCase() !== "false",
+  };
+}
+
+export function getPostHogClientConfigScript(): string | null {
+  const config = resolvePublicPostHogConfig();
+  if (!config) return null;
+
+  return [
+    "<script data-agent-native-posthog-config>",
+    "window.__AGENT_NATIVE_CONFIG__=Object.assign({},window.__AGENT_NATIVE_CONFIG__,",
+    JSON.stringify(config),
+    ");",
+    "</script>",
+  ].join("");
+}

package/src/server/request-context.ts

@@ -140,6 +140,12 @@ export interface RequestContext {
    */
   authCapability?: string;
   timezone?: string;
+  /**
+   * The caller's browser analytics session id, when the request came from a
+   * page. Emitted as PostHog's `$session_id` so agent traces join to session
+   * replay; never used for authorization.
+   */
+  browserSessionId?: string;
   /**
    * Set when code reads authenticated request context. Public SSR shell/data
    * should not depend on this value; user/org-specific reads belong behind

package/src/server/sentry-config.ts

@@ -1,3 +1,5 @@
+import { resolveDeployEnvironment } from "./deploy-environment.js";
+
 function firstNonEmpty(
   ...values: Array<string | undefined>
 ): string | undefined {
@@ -25,15 +27,9 @@ function resolveSentryDsnFromKeyProject(): string | undefined {
   return `https://${key}@${host}/${projectId}`;
 }
 
+/** @deprecated Use `resolveDeployEnvironment()` — it is not Sentry-specific. */
 export function resolveSentryEnvironment(): string {
-  return (
-    firstNonEmpty(
-      process.env.SENTRY_ENVIRONMENT,
-      process.env.NETLIFY_CONTEXT,
-      process.env.VERCEL_ENV,
-      process.env.NODE_ENV,
-    ) ?? "production"
-  );
+  return resolveDeployEnvironment();
 }
 
 export function resolveServerSentryDsn(): string | undefined {

package/src/server/sentry-plugin.ts

@@ -1,4 +1,4 @@
-import { getHeader, getMethod, type H3Event } from "h3";
+import { type H3Event } from "h3";
 
 import { getSession } from "./auth.js";
 import { registerErrorCaptureProvider } from "./capture-error.js";
@@ -9,12 +9,16 @@ import { registerErrorCaptureProvider } from "./capture-error.js";
  * Wires three pieces:
  *   1. On startup, `initServerSentry()` reads `SENTRY_SERVER_DSN`/`SENTRY_DSN` and arms
  *      the SDK (no-op when the env var is unset).
- *   2. On every request, hook into Nitro's `request` event: resolve the
+ *   2. Registers Sentry as a `captureError()` backend, so route errors and
+ *      explicit captures alike reach it through the shared registry.
+ *   3. On every request, hook into Nitro's `request` event: resolve the
  *      session via `getSession(event)` and tag the per-request isolation
  *      scope with the user's id/email/orgId. Wrapped in try/catch so a
  *      session-resolution failure can never 500 the request.
- *   3. On every Nitro `error` event, capture the exception with the route,
- *      method, and user-agent attached as searchable tags.
+ *
+ * It does NOT hook Nitro's `error` event — that is provider-agnostic and lives
+ * in `core-routes-plugin.ts`, so error reporting works with PostHog (or any
+ * other backend) configured and no Sentry DSN set at all.
  *
  * Mounted as a default plugin from `framework-request-handler.ts` —
  * templates that don't define `server/plugins/sentry.ts` get this for
@@ -44,14 +48,6 @@ function readRoute(event: H3Event): string | undefined {
   }
 }
 
-function readUserAgent(event: H3Event): string | undefined {
-  try {
-    return getHeader(event, "user-agent");
-  } catch {
-    return undefined;
-  }
-}
-
 /**
  * Skip session resolution for paths that obviously don't need one. Avoids
  * a DB round-trip on every static-asset / favicon / public-share request
@@ -109,23 +105,11 @@ export function createSentryPlugin(): NitroPluginDef {
       setSentryRequestContext({ userEmail: ctx.userEmail, orgId: ctx.orgId });
     });
 
-    // Per-error: capture with route/method/UA tags. Nitro's `error` hook
-    // signature is (error, { event, tags }) — we forward what we can.
-    nitroApp.hooks?.hook?.(
-      "error",
-      (error: unknown, ctx?: { event?: H3Event }) => {
-        try {
-          const event = ctx?.event;
-          captureRouteError(error, {
-            route: event ? readRoute(event) : undefined,
-            method: event ? getMethod(event) : undefined,
-            userAgent: event ? readUserAgent(event) : undefined,
-          });
-        } catch {
-          // Sentry capture must never escape into Nitro's error path.
-        }
-      },
-    );
+    // Route errors are NOT hooked here. `core-routes-plugin.ts` owns the
+    // provider-agnostic Nitro `error` hook and routes it through
+    // `captureError()`, which reaches Sentry via the registration above along
+    // with every other configured backend. Hooking it here too would report
+    // each route error to Sentry twice.
   };
 }
 

package/src/server/sentry.ts

@@ -1,7 +1,3 @@
-import fs from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-
 /**
  * Server-side Sentry initialization for Nitro.
  *
@@ -24,36 +20,18 @@ import * as Sentry from "@sentry/node";
 
 import type { AuthSession } from "./auth.js";
 import {
-  resolveSentryEnvironment,
-  resolveServerSentryDsn,
-} from "./sentry-config.js";
+  resolveDeployEnvironment,
+  resolveServerRelease,
+} from "./deploy-environment.js";
+import {
+  errorSignalFromSentryEvent,
+  shouldReportErrorSignal,
+} from "./error-noise-filter.js";
+import { resolveServerSentryDsn } from "./sentry-config.js";
 
 let _initStarted = false;
 let _initSucceeded = false;
 
-/**
- * Resolve the agent-native version baked into core's package.json so Sentry
- * "release" reflects the running framework version. Mirrors how the CLI
- * computes `_version` — same dist layout, same fallback string. Guarded so
- * a missing/unreadable package.json never crashes server boot.
- */
-function resolveServerRelease(): string {
-  const explicit = process.env.AGENT_NATIVE_RELEASE;
-  if (explicit) return explicit;
-  try {
-    const here = path.dirname(fileURLToPath(import.meta.url));
-    // dist/server/sentry.js → ../../package.json
-    const pkgPath = path.resolve(here, "../../package.json");
-    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8")) as {
-      version?: string;
-    };
-    if (pkg?.version) return `agent-native-server@${pkg.version}`;
-  } catch {
-    // ignore — fall through to "unknown"
-  }
-  return "agent-native-server@unknown";
-}
-
 function parseTracesSampleRate(): number {
   const raw = process.env.SENTRY_SERVER_TRACES_SAMPLE_RATE;
   if (!raw) return 0;
@@ -88,7 +66,7 @@ export function initServerSentry(): boolean {
 
   Sentry.init({
     dsn,
-    environment: resolveSentryEnvironment(),
+    environment: resolveDeployEnvironment(),
     release: resolveServerRelease(),
     tracesSampleRate: parseTracesSampleRate(),
     // sendDefaultPii MUST stay false — the framework runs inside customer
@@ -96,133 +74,12 @@ export function initServerSentry(): boolean {
     // cookies, or process.env contents to Sentry without explicit consent.
     sendDefaultPii: false,
     beforeSend(event) {
-      // Drop expected user-input rejections so they don't pollute Sentry
-      // with non-bug noise. Mirrors the CLI's drop list — the framework
-      // and CLI both throw `ValidationError` for the same class of input
-      // failures, and exception type comes through as the class name.
-      const exceptionType = event.exception?.values?.[0]?.type;
-      if (
-        exceptionType === "ValidationError" ||
-        event.tags?.handled === "validation"
-      ) {
-        return null;
-      }
-      // Drop access-control rejections (caller lacks permission, signed
-      // out, etc.). These are 4xx user-facing errors that propagated to
-      // Nitro's error hook because a route forgot to catch them — fixing
-      // the route is the right answer, but in the meantime they bury
-      // real bugs and don't represent server failures. Auth-routes use
-      // `captureAuthError` directly with `level: warning` so this filter
-      // only sees the generic-handler escape path.
-      if (
-        exceptionType === "ForbiddenError" ||
-        exceptionType === "UnauthorizedError"
-      ) {
+      // Drop rules live in `error-noise-filter.ts` so every backend applies
+      // the same ones — they describe which server errors are non-bugs in
+      // this framework, not a Sentry preference.
+      if (!shouldReportErrorSignal(errorSignalFromSentryEvent(event))) {
         return null;
       }
-      // Drop "socket hang up" unhandled promise rejections that fire from
-      // Lambda freeze cycles. AWS Lambda recycles long-lived sockets (e.g.
-      // MCP Streamable HTTP long-polls, keep-alive HTTP agents) ~60s after
-      // a function returns 200; the next thaw delivers a socket-end event
-      // whose Promise has nobody left to await it. The function itself
-      // already returned correctly, so there's no user impact — just
-      // ~10k events/day of noise. The narrow shape (unhandled rejection
-      // from `Socket.socketOnEnd` in `node:_http_client`) keeps real
-      // application-thrown socket errors from being silenced.
-      const exceptionValue = event.exception?.values?.[0]?.value ?? "";
-      const exceptionMechanism = event.exception?.values?.[0]?.mechanism?.type;
-      const isUnhandledRejection =
-        typeof exceptionMechanism === "string" &&
-        exceptionMechanism.endsWith("onunhandledrejection");
-      if (exceptionValue === "socket hang up" && isUnhandledRejection) {
-        const frames = event.exception?.values?.[0]?.stacktrace?.frames ?? [];
-        const fromHttpClient = frames.some(
-          (f) =>
-            f?.function === "Socket.socketOnEnd" ||
-            f?.filename === "node:_http_client",
-        );
-        if (fromHttpClient) {
-          return null;
-        }
-      }
-      // Drop SDK-only ErrorEvent promise rejections. These arrive as Node
-      // unhandled rejections with no application frames — typically the Neon
-      // serverless driver's WebSocket dying across a Lambda freeze/thaw and
-      // rejecting a floating promise with the raw ErrorEvent (the per-client
-      // logger in db/client.ts already records these with context). Keep any
-      // event with real app frames so thrown ErrorEvents stay visible.
-      //
-      // "Application frame" must exclude the Sentry SDK's own bundled chunks:
-      // serverless bundles place them under the app root (e.g.
-      // `/var/task/_libs/@sentry/node+….mjs`), outside node_modules, so the
-      // SDK marks them in_app and the unhandled-rejection instrumentation
-      // stack alone would defeat this filter.
-      if (exceptionValue === "[object ErrorEvent]" && isUnhandledRejection) {
-        const frames = event.exception?.values?.[0]?.stacktrace?.frames ?? [];
-        const hasApplicationFrame = frames.some(
-          (frame) =>
-            frame?.in_app && !String(frame?.filename ?? "").includes("sentry"),
-        );
-        const hasSentryFrame = frames.some((frame) =>
-          String(frame?.filename ?? "").includes("sentry"),
-        );
-        if (!hasApplicationFrame && hasSentryFrame) {
-          return null;
-        }
-      }
-      const metadata = (
-        event as {
-          metadata?: {
-            filename?: unknown;
-            value?: unknown;
-          };
-        }
-      ).metadata;
-      if (
-        metadata?.value === "[object ErrorEvent]" &&
-        !event.exception?.values?.length &&
-        String(metadata.filename ?? "").includes("sentry")
-      ) {
-        return null;
-      }
-      // h3's `createError({ statusCode: 4xx, ... })` produces an
-      // `HTTPError` (h3 v2) / `H3Error` (h3 v1). 4xx HTTPErrors are
-      // handler-controlled "expected failure" responses (404 not found,
-      // 400 bad input) that route through Nitro's error hook just
-      // because they bubble out of `defineEventHandler`. They aren't
-      // bugs — they're the documented way to return a 4xx in h3.
-      // Capture only when the statusCode looks like 5xx (real failure)
-      // or is missing (generic Error masquerading as HTTPError).
-      if (exceptionType === "HTTPError" || exceptionType === "H3Error") {
-        const statusCode = (event.tags?.statusCode ??
-          (
-            event.contexts as
-              | Record<string, Record<string, unknown>>
-              | undefined
-          )?.h3?.statusCode) as number | string | undefined;
-        const code =
-          typeof statusCode === "string"
-            ? parseInt(statusCode, 10)
-            : statusCode;
-        if (typeof code === "number" && code >= 400 && code < 500) {
-          return null;
-        }
-        // No statusCode in the event payload — fall back to matching the
-        // common 4xx messages so handler-thrown 404/400/403/401 don't
-        // pollute Sentry. This is a heuristic, but the alternatives
-        // (every 4xx becomes a "real" issue, or we patch every route to
-        // catch+return) are worse.
-        const value = event.exception?.values?.[0]?.value ?? "";
-        if (
-          /^Cannot find any route matching/i.test(value) ||
-          / not found$/i.test(value) ||
-          /Unauthenticated$/i.test(value) ||
-          /^Unauthorized$/i.test(value) ||
-          /^No access to /i.test(value)
-        ) {
-          return null;
-        }
-      }
 
       // Defense in depth: scrub PII even if some integration auto-attached
       // request metadata despite sendDefaultPii: false.

package/src/server/ssr-handler.ts

@@ -36,6 +36,7 @@ import {
   stripAppBasePath as canonicalStripAppBasePath,
 } from "./app-base-path.js";
 import { captureError } from "./capture-error.js";
+import { getPostHogClientConfigScript } from "./posthog-config.js";
 import { runWithRequestContext } from "./request-context.js";
 import {
   getRealtimeClientConfigScript,
@@ -357,7 +358,11 @@ async function rewriteMountedResponse(
   requestUrl: string,
 ): Promise<Response> {
   const clientConfigScript =
-    [getSentryClientConfigScript(), getRealtimeClientConfigScript()]
+    [
+      getSentryClientConfigScript(),
+      getPostHogClientConfigScript(),
+      getRealtimeClientConfigScript(),
+    ]
       .filter(Boolean)
       .join("") || null;
   const headers = new Headers(response.headers);

package/src/shared/mcp-embed-headers.ts

@@ -1,5 +1,5 @@
 export const MCP_EMBED_CORS_ALLOW_HEADERS =
-  "Content-Type,Authorization,X-Requested-With,X-Request-Source,X-Agent-Native-CSRF,X-Agent-Native-Frontend,X-Agent-Native-Client-Compatibility,X-Agent-Native-Build-Id,X-User-Timezone,X-Agent-Native-Embed-Target,X-Agent-Native-Embed-Transplant";
+  "Content-Type,Authorization,X-Requested-With,X-Request-Source,X-Agent-Native-CSRF,X-Agent-Native-Frontend,X-Agent-Native-Client-Compatibility,X-Agent-Native-Build-Id,X-User-Timezone,X-Agent-Native-Session-Id,X-Agent-Native-Embed-Target,X-Agent-Native-Embed-Transplant";
 export const EMBED_TRANSPLANT_HEADER = "x-agent-native-embed-transplant";
 
 const CLAUDE_MCP_CONTENT_HOST_RE = /^[a-f0-9]{32}\.claudemcpcontent\.com$/i;