@agent-native/core 0.108.0 → 0.109.1

package/corpus/templates/analytics/server/lib/analytics-alerts.ts

@@ -135,6 +135,12 @@ function nowIso(): string {
 
 const ALERT_RULE_RUNNING_STALE_MS = 15 * 60 * 1000;
 const DEFAULT_HTTP_5XX_ALERT_ID_PREFIX = "default-http-5xx-spike";
+const DEFAULT_AGENT_CHAT_STUCK_ALERT_ID_PREFIX =
+  "default-agent-chat-stuck-spike";
+const DEFAULT_AGENT_CHAT_STUCK_ALERT_THRESHOLD = 3;
+const DEFAULT_AGENT_CHAT_STUCK_ALERT_WINDOW_MINUTES = 10;
+const DEFAULT_AGENT_CHAT_STUCK_ALERT_COOLDOWN_MINUTES = 60;
+const DEFAULT_ALERT_SCOPE_PAGE_SIZE = 500;
 const ALERT_RULE_DEFAULTS_KEY = "analytics-alert-rule-defaults";
 
 function safeJsonParse<T>(raw: unknown, fallback: T): T {
@@ -296,6 +302,14 @@ function defaultHttp5xxAlertEnabled(): boolean {
   return currentDeployHostname() === "analytics.agent-native.com";
 }
 
+function defaultAgentChatStuckAlertEnabled(): boolean {
+  const configured = boolEnv(
+    "ANALYTICS_DEFAULT_AGENT_CHAT_STUCK_ALERT_ENABLED",
+  );
+  if (configured !== null) return configured;
+  return currentDeployHostname() === "analytics.agent-native.com";
+}
+
 function envInt(name: string, fallback: number, min: number, max: number) {
   const raw = process.env[name]?.trim();
   if (!raw) return fallback;
@@ -305,18 +319,30 @@ function envInt(name: string, fallback: number, min: number, max: number) {
     : fallback;
 }
 
-function defaultHttp5xxAlertId(ownerEmail: string, orgId: string | null) {
+function defaultAlertId(
+  prefix: string,
+  ownerEmail: string,
+  orgId: string | null,
+) {
   const hash = createHash("sha256")
     .update(`${ownerEmail.toLowerCase()}|${orgId ?? ""}`)
     .digest("hex")
     .slice(0, 10);
-  return `${DEFAULT_HTTP_5XX_ALERT_ID_PREFIX}-${hash}`;
+  return `${prefix}-${hash}`;
 }
 
-async function defaultHttp5xxAlertScopes(): Promise<AccessCtx[]> {
+async function defaultAnalyticsAlertScopePage(offset: number): Promise<{
+  scopes: AccessCtx[];
+  hasMore: boolean;
+}> {
   const ownerEmail = process.env.ANALYTICS_DEFAULT_ALERT_OWNER_EMAIL?.trim();
   const orgId = process.env.ANALYTICS_DEFAULT_ALERT_ORG_ID?.trim() || null;
-  if (ownerEmail) return [{ email: ownerEmail, orgId }];
+  if (ownerEmail) {
+    return {
+      scopes: offset === 0 ? [{ email: ownerEmail, orgId }] : [],
+      hasMore: false,
+    };
+  }
 
   const db = getDb() as any;
   const rows = await db
@@ -326,7 +352,16 @@ async function defaultHttp5xxAlertScopes(): Promise<AccessCtx[]> {
     })
     .from(schema.analyticsPublicKeys)
     .where(isNull(schema.analyticsPublicKeys.revokedAt))
-    .limit(1000);
+    .groupBy(
+      schema.analyticsPublicKeys.ownerEmail,
+      schema.analyticsPublicKeys.orgId,
+    )
+    .orderBy(
+      asc(schema.analyticsPublicKeys.ownerEmail),
+      asc(schema.analyticsPublicKeys.orgId),
+    )
+    .limit(DEFAULT_ALERT_SCOPE_PAGE_SIZE)
+    .offset(offset);
 
   const seen = new Set<string>();
   const scopes: AccessCtx[] = [];
@@ -342,7 +377,10 @@ async function defaultHttp5xxAlertScopes(): Promise<AccessCtx[]> {
     seen.add(key);
     scopes.push({ email, orgId: scopeOrgId });
   }
-  return scopes;
+  return {
+    scopes,
+    hasMore: rows.length === DEFAULT_ALERT_SCOPE_PAGE_SIZE,
+  };
 }
 
 function rowToRule(row: any): AnalyticsAlertRule {
@@ -517,10 +555,20 @@ export async function deleteAnalyticsAlertRule(
     });
   }
   const db = getDb() as any;
-  await db.delete(schema.analyticsAlertRules).where(ownerWhere(ctx, id));
+  const seededDefault =
+    id.startsWith(`${DEFAULT_HTTP_5XX_ALERT_ID_PREFIX}-`) ||
+    id.startsWith(`${DEFAULT_AGENT_CHAT_STUCK_ALERT_ID_PREFIX}-`);
+  if (seededDefault) {
+    await db
+      .update(schema.analyticsAlertRules)
+      .set({ enabled: false, updatedAt: nowIso() })
+      .where(ownerWhere(ctx, id));
+  } else {
+    await db.delete(schema.analyticsAlertRules).where(ownerWhere(ctx, id));
+  }
   recordChange({
     source: "analytics-alert-rules",
-    type: "delete",
+    type: seededDefault ? "change" : "delete",
     key: existing.id,
     owner: existing.ownerEmail,
     orgId: existing.orgId ?? undefined,
@@ -529,6 +577,20 @@ export async function deleteAnalyticsAlertRule(
 
 const DEFAULT_ALERT_SEED_CHUNK_SIZE = 500;
 
+interface DefaultAnalyticsAlertDefinition {
+  idPrefix: string;
+  name: string;
+  description: string;
+  eventName: string;
+  filters: AnalyticsAlertFilter[];
+  threshold: number;
+  thresholdMode?: AnalyticsAlertThresholdMode;
+  distinctBy?: string | null;
+  windowMinutes: number;
+  cooldownMinutes: number;
+  severity: AnalyticsAlertSeverity;
+}
+
 function chunkArray<T>(items: T[], size: number): T[][] {
   const chunks: T[][] = [];
   for (let i = 0; i < items.length; i += size) {
@@ -537,95 +599,155 @@ function chunkArray<T>(items: T[], size: number): T[][] {
   return chunks;
 }
 
-export async function ensureDefaultHttp5xxSpikeAlertRules(): Promise<{
+function defaultAnalyticsAlertDefinitions(): DefaultAnalyticsAlertDefinition[] {
+  const definitions: DefaultAnalyticsAlertDefinition[] = [];
+
+  if (defaultHttp5xxAlertEnabled()) {
+    definitions.push({
+      idPrefix: DEFAULT_HTTP_5XX_ALERT_ID_PREFIX,
+      name: "Hosted app HTTP 5xx spike",
+      description:
+        "Default Agent Native alert for a spike in server responses with 5xx status codes.",
+      eventName: "http.response",
+      filters: [{ field: "properties.status_class", value: "5xx" }],
+      threshold: envInt(
+        "ANALYTICS_DEFAULT_HTTP_5XX_ALERT_THRESHOLD",
+        5,
+        1,
+        1000,
+      ),
+      windowMinutes: envInt(
+        "ANALYTICS_DEFAULT_HTTP_5XX_ALERT_WINDOW_MINUTES",
+        5,
+        1,
+        60,
+      ),
+      cooldownMinutes: envInt(
+        "ANALYTICS_DEFAULT_HTTP_5XX_ALERT_COOLDOWN_MINUTES",
+        30,
+        0,
+        24 * 60,
+      ),
+      severity: "critical",
+    });
+  }
+
+  if (defaultAgentChatStuckAlertEnabled()) {
+    definitions.push({
+      idPrefix: DEFAULT_AGENT_CHAT_STUCK_ALERT_ID_PREFIX,
+      name: "Hosted agent chat stuck spike",
+      description:
+        "Default Agent Native alert for a spike in agent chats detected as stuck.",
+      eventName: "agent_chat_stuck_detected",
+      filters: [],
+      threshold: envInt(
+        "ANALYTICS_DEFAULT_AGENT_CHAT_STUCK_ALERT_THRESHOLD",
+        DEFAULT_AGENT_CHAT_STUCK_ALERT_THRESHOLD,
+        1,
+        1000,
+      ),
+      thresholdMode: "distinct_count",
+      distinctBy: "properties.runId",
+      windowMinutes: envInt(
+        "ANALYTICS_DEFAULT_AGENT_CHAT_STUCK_ALERT_WINDOW_MINUTES",
+        DEFAULT_AGENT_CHAT_STUCK_ALERT_WINDOW_MINUTES,
+        1,
+        60,
+      ),
+      cooldownMinutes: envInt(
+        "ANALYTICS_DEFAULT_AGENT_CHAT_STUCK_ALERT_COOLDOWN_MINUTES",
+        DEFAULT_AGENT_CHAT_STUCK_ALERT_COOLDOWN_MINUTES,
+        0,
+        24 * 60,
+      ),
+      severity: "critical",
+    });
+  }
+
+  return definitions;
+}
+
+export async function ensureDefaultAnalyticsAlertRules(): Promise<{
   checked: number;
   created: number;
 }> {
-  if (!defaultHttp5xxAlertEnabled()) return { checked: 0, created: 0 };
-
-  const scopes = await defaultHttp5xxAlertScopes();
-  if (!scopes.length) return { checked: 0, created: 0 };
+  const definitions = defaultAnalyticsAlertDefinitions();
+  if (!definitions.length) return { checked: 0, created: 0 };
 
   const db = getDb() as any;
-  const threshold = envInt(
-    "ANALYTICS_DEFAULT_HTTP_5XX_ALERT_THRESHOLD",
-    5,
-    1,
-    1000,
-  );
-  const windowMinutes = envInt(
-    "ANALYTICS_DEFAULT_HTTP_5XX_ALERT_WINDOW_MINUTES",
-    5,
-    1,
-    60,
-  );
-  const cooldownMinutes = envInt(
-    "ANALYTICS_DEFAULT_HTTP_5XX_ALERT_COOLDOWN_MINUTES",
-    30,
-    0,
-    24 * 60,
-  );
-
-  const scopesById = new Map<string, AccessCtx>();
-  for (const scope of scopes) {
-    scopesById.set(defaultHttp5xxAlertId(scope.email, scope.orgId), scope);
-  }
-  const allIds = Array.from(scopesById.keys());
-
-  const existingIds = new Set<string>();
-  for (const idChunk of chunkArray(allIds, DEFAULT_ALERT_SEED_CHUNK_SIZE)) {
-    const rows = await db
-      .select({ id: schema.analyticsAlertRules.id })
-      .from(schema.analyticsAlertRules)
-      .where(inArray(schema.analyticsAlertRules.id, idChunk));
-    for (const row of rows) existingIds.add(row.id);
-  }
+  let checked = 0;
+  let created = 0;
+  let offset = 0;
+  while (true) {
+    const page = await defaultAnalyticsAlertScopePage(offset);
+    const candidatesById = new Map<
+      string,
+      { definition: DefaultAnalyticsAlertDefinition; scope: AccessCtx }
+    >();
+    for (const scope of page.scopes) {
+      for (const definition of definitions) {
+        candidatesById.set(
+          defaultAlertId(definition.idPrefix, scope.email, scope.orgId),
+          { definition, scope },
+        );
+      }
+    }
+    const allIds = Array.from(candidatesById.keys());
+    checked += allIds.length;
+
+    const existingIds = new Set<string>();
+    for (const idChunk of chunkArray(allIds, DEFAULT_ALERT_SEED_CHUNK_SIZE)) {
+      const rows = await db
+        .select({ id: schema.analyticsAlertRules.id })
+        .from(schema.analyticsAlertRules)
+        .where(inArray(schema.analyticsAlertRules.id, idChunk));
+      for (const row of rows) existingIds.add(row.id);
+    }
 
-  const missingIds = allIds.filter((id) => !existingIds.has(id));
-  if (!missingIds.length) return { checked: scopes.length, created: 0 };
+    const now = nowIso();
+    const rowsToInsert = allIds
+      .filter((id) => !existingIds.has(id))
+      .map((id) => {
+        const { definition, scope } = candidatesById.get(id)!;
+        return {
+          id,
+          name: definition.name,
+          description: definition.description,
+          eventName: definition.eventName,
+          filters: JSON.stringify(definition.filters),
+          thresholdMode: definition.thresholdMode ?? ("event_count" as const),
+          distinctBy: definition.distinctBy ?? null,
+          threshold: definition.threshold,
+          windowMinutes: definition.windowMinutes,
+          cooldownMinutes: definition.cooldownMinutes,
+          severity: definition.severity,
+          channels: JSON.stringify(["inbox"]),
+          emailRecipients: JSON.stringify([]),
+          enabled: true,
+          createdAt: now,
+          updatedAt: now,
+          ownerEmail: scope.email,
+          orgId: scope.orgId,
+        };
+      });
 
-  const now = nowIso();
-  const rowsToInsert = missingIds.map((id) => {
-    const scope = scopesById.get(id)!;
-    return {
-      id,
-      name: "Hosted app HTTP 5xx spike",
-      description:
-        "Default Agent Native alert for a spike in server responses with 5xx status codes.",
-      eventName: "http.response",
-      filters: JSON.stringify([
-        { field: "properties.status_class", value: "5xx" },
-      ]),
-      thresholdMode: "event_count" as const,
-      distinctBy: null,
-      threshold,
-      windowMinutes,
-      cooldownMinutes,
-      severity: "critical" as const,
-      channels: JSON.stringify(["inbox"]),
-      emailRecipients: JSON.stringify([]),
-      enabled: true,
-      createdAt: now,
-      updatedAt: now,
-      ownerEmail: scope.email,
-      orgId: scope.orgId,
-    };
-  });
+    for (const rowChunk of chunkArray(
+      rowsToInsert,
+      DEFAULT_ALERT_SEED_CHUNK_SIZE,
+    )) {
+      const inserted = await db
+        .insert(schema.analyticsAlertRules)
+        .values(rowChunk)
+        .onConflictDoNothing()
+        .returning({ id: schema.analyticsAlertRules.id });
+      created += inserted.length;
+    }
 
-  let created = 0;
-  for (const rowChunk of chunkArray(
-    rowsToInsert,
-    DEFAULT_ALERT_SEED_CHUNK_SIZE,
-  )) {
-    const inserted = await db
-      .insert(schema.analyticsAlertRules)
-      .values(rowChunk)
-      .onConflictDoNothing()
-      .returning({ id: schema.analyticsAlertRules.id });
-    created += inserted.length;
+    if (!page.hasMore) break;
+    offset += DEFAULT_ALERT_SCOPE_PAGE_SIZE;
   }
 
-  return { checked: scopes.length, created };
+  return { checked, created };
 }
 
 export async function listEnabledAnalyticsAlertRules(options: {

package/corpus/templates/analytics/server/lib/analytics-connector-catalog.ts

@@ -1,10 +1,14 @@
 /**
  * The deliberately small authenticated MCP surface for Analytics.
  *
- * Keep this list read-only and incident-focused. In particular, do not add
- * raw replay-event/blob actions or dashboard/data mutation actions here.
+ * Keep this list read-only and bounded. It includes incident evidence plus
+ * the narrow Gong deep-dive/synthesis/evidence operations used by sibling
+ * apps. Do not add raw replay blobs or dashboard/data mutation actions here.
  */
 export const ANALYTICS_CONNECTOR_CATALOG = [
+  "account-deep-dive",
+  "gong-calls",
+  "gong-native-insights",
   "list-session-recordings",
   "get-session-replay-summary",
   "get-session-replay-timeline",

package/corpus/templates/analytics/server/lib/error-capture.ts

@@ -373,6 +373,11 @@ export function normalizeFrameFile(file: string | null): string {
   // Strip bundler content hashes in the basename: main.4f3a2b1c.js -> main.js
   out = out.replace(/([._-])[0-9a-fA-F]{8,}(?=\.[a-z0-9]+$)/i, "");
   out = out.replace(/([._-])[0-9a-fA-F]{8,}$/i, "");
+  // Vite also emits eight-character base64url hashes, e.g. entry-CVi_y2nS.js.
+  out = out.replace(
+    /([._-])(?=[A-Za-z0-9_-]{8}\.[a-z0-9]+$)(?=[A-Za-z0-9_-]*[A-Z0-9_])[A-Za-z0-9_-]{8}(?=\.[a-z0-9]+$)/,
+    "",
+  );
   return out;
 }
 
@@ -412,11 +417,15 @@ export function fingerprint(
   frames: ParsedStackFrame[],
   message: string,
 ): string {
+  // The client uses this synthetic type for bare Error rejections. Keep it
+  // in the same group as window errors while retaining the original event
+  // type in the stored occurrence.
+  const groupingType = type === "UnhandledRejection" ? "Error" : type;
   const frame = topFrame(frames);
   const key =
     frame && (frame.file || frame.function)
-      ? `${type}|${normalizeFrameFile(frame.file)}|${frame.function ?? ""}`
-      : `${type}|${normalizeMessageForFingerprint(message)}`;
+      ? `${groupingType}|${normalizeFrameFile(frame.file)}|${frame.function ?? ""}`
+      : `${groupingType}|${normalizeMessageForFingerprint(message)}`;
   return hashHex(key);
 }
 
@@ -1123,6 +1132,28 @@ function recordingPath(recordingId: string | null): string | null {
   return recordingId ? `/sessions/${recordingId}` : null;
 }
 
+async function accessibleClientRecordingId(
+  scope: ErrorReadScope,
+  recordingId: string,
+): Promise<string | null> {
+  const db = getDb() as any;
+  const [row] = await db
+    .select({ clientRecordingId: schema.sessionRecordings.clientRecordingId })
+    .from(schema.sessionRecordings)
+    .where(
+      and(
+        eq(schema.sessionRecordings.id, recordingId),
+        accessFilter(
+          schema.sessionRecordings,
+          schema.sessionRecordingShares,
+          accessCtx(scope),
+        ),
+      ),
+    )
+    .limit(1);
+  return row?.clientRecordingId ?? null;
+}
+
 async function sparklinesForIssues(
   issueIds: string[],
 ): Promise<Map<string, number[]>> {
@@ -1194,9 +1225,19 @@ export async function listErrorIssues(
       ),
     ];
     if (sessionRecordingId) {
-      occurrenceConditions.push(
-        eq(schema.errorEvents.sessionRecordingId, sessionRecordingId),
+      const clientRecordingId = await accessibleClientRecordingId(
+        scope,
+        sessionRecordingId,
       );
+      const recordingConditions: any[] = [
+        eq(schema.errorEvents.sessionRecordingId, sessionRecordingId),
+      ];
+      if (clientRecordingId) {
+        recordingConditions.push(
+          eq(schema.errorEvents.clientRecordingId, clientRecordingId),
+        );
+      }
+      occurrenceConditions.push(or(...recordingConditions));
     }
     if (userId) {
       occurrenceConditions.push(
@@ -1241,6 +1282,13 @@ export async function listErrorIssues(
     .limit(limit);
 
   const sparklines = await sparklinesForIssues(rows.map((row: any) => row.id));
+  const { byId: accessibleLastRecordings } = await resolveAccessibleRecordings(
+    scope,
+    rows
+      .map((row: any) => row.lastSessionRecordingId)
+      .filter((value: unknown): value is string => Boolean(value)),
+    [],
+  );
   const issues = rows.map((row: any) => ({
     id: row.id,
     fingerprint: row.fingerprint,
@@ -1253,8 +1301,17 @@ export async function listErrorIssues(
     lastSeenAt: row.lastSeenAt,
     eventCount: Number(row.eventCount ?? 0),
     usersAffected: Number(row.usersAffected ?? 0),
-    lastSessionRecordingId: row.lastSessionRecordingId ?? null,
-    lastSessionRecordingPath: recordingPath(row.lastSessionRecordingId ?? null),
+    lastSessionRecordingId:
+      row.lastSessionRecordingId &&
+      accessibleLastRecordings.has(row.lastSessionRecordingId)
+        ? row.lastSessionRecordingId
+        : null,
+    lastSessionRecordingPath: recordingPath(
+      row.lastSessionRecordingId &&
+        accessibleLastRecordings.has(row.lastSessionRecordingId)
+        ? row.lastSessionRecordingId
+        : null,
+    ),
     assignee: row.assignee ?? null,
     app: row.app ?? null,
     template: row.template ?? null,
@@ -1390,6 +1447,9 @@ export async function getErrorIssue(
         .filter((value: unknown): value is string => Boolean(value)),
     ),
   ) as string[];
+  if (issueRow.lastSessionRecordingId) {
+    srIds.push(issueRow.lastSessionRecordingId);
+  }
   const clientIds = Array.from(
     new Set(
       eventRows
@@ -1467,9 +1527,16 @@ export async function getErrorIssue(
     lastSeenAt: issueRow.lastSeenAt,
     eventCount: Number(issueRow.eventCount ?? 0),
     usersAffected: Number(issueRow.usersAffected ?? 0),
-    lastSessionRecordingId: issueRow.lastSessionRecordingId ?? null,
+    lastSessionRecordingId:
+      issueRow.lastSessionRecordingId &&
+      byId.has(issueRow.lastSessionRecordingId)
+        ? issueRow.lastSessionRecordingId
+        : null,
     lastSessionRecordingPath: recordingPath(
-      issueRow.lastSessionRecordingId ?? null,
+      issueRow.lastSessionRecordingId &&
+        byId.has(issueRow.lastSessionRecordingId)
+        ? issueRow.lastSessionRecordingId
+        : null,
     ),
     assignee: issueRow.assignee ?? null,
     app: issueRow.app ?? null,

package/corpus/templates/analytics/server/lib/gong-native-policy.ts

@@ -0,0 +1,72 @@
+import {
+  getRequestOrgId,
+  getRequestUserEmail,
+} from "@agent-native/core/server";
+import {
+  getOrgSetting,
+  getUserSetting,
+  putOrgSetting,
+  putUserSetting,
+} from "@agent-native/core/settings";
+
+export const GONG_NATIVE_INSIGHTS_SETTING_KEY = "gong-native-insights-policy";
+
+export interface GongNativeInsightsPolicy {
+  enabled: boolean;
+  configured: boolean;
+  scope: "workspace" | "user" | "none";
+  updatedAt: string | null;
+}
+
+function parsePolicy(
+  value: Record<string, unknown> | null,
+  scope: GongNativeInsightsPolicy["scope"],
+): GongNativeInsightsPolicy {
+  return {
+    enabled: value?.enabled === true,
+    configured: value != null,
+    scope,
+    updatedAt: typeof value?.updatedAt === "string" ? value.updatedAt : null,
+  };
+}
+
+export async function readGongNativeInsightsPolicy(): Promise<GongNativeInsightsPolicy> {
+  const orgId = getRequestOrgId() || null;
+  if (orgId) {
+    return parsePolicy(
+      await getOrgSetting(orgId, GONG_NATIVE_INSIGHTS_SETTING_KEY),
+      "workspace",
+    );
+  }
+
+  const email = getRequestUserEmail();
+  if (email) {
+    return parsePolicy(
+      await getUserSetting(email, GONG_NATIVE_INSIGHTS_SETTING_KEY),
+      "user",
+    );
+  }
+
+  return parsePolicy(null, "none");
+}
+
+export async function writeGongNativeInsightsPolicy(
+  enabled: boolean,
+): Promise<GongNativeInsightsPolicy> {
+  const orgId = getRequestOrgId() || null;
+  const email = getRequestUserEmail();
+  const value = {
+    enabled,
+    updatedAt: new Date().toISOString(),
+    updatedBy: email ?? "authenticated-agent",
+  };
+
+  if (orgId) {
+    await putOrgSetting(orgId, GONG_NATIVE_INSIGHTS_SETTING_KEY, value);
+    return parsePolicy(value, "workspace");
+  }
+  if (!email) throw new Error("no authenticated user");
+
+  await putUserSetting(email, GONG_NATIVE_INSIGHTS_SETTING_KEY, value);
+  return parsePolicy(value, "user");
+}