@agent-native/core 0.107.2 → 0.109.0

package/corpus/templates/analytics/server/handlers/slack.ts

@@ -10,11 +10,11 @@ import {
   runApiHandlerWithContext,
 } from "../lib/credentials";
 import {
-  listChannels,
   getChannelHistory,
-  searchMessages,
-  resolveUsers,
   getTeamInfo,
+  listChannelsWithCoverage,
+  resolveUsersWithCoverage,
+  searchMessages,
   type Workspace,
   type SlackMessage,
 } from "../lib/slack";
@@ -49,12 +49,21 @@ export const handleSlackTeam = defineEventHandler((event) =>
 export const handleSlackChannels = defineEventHandler((event) =>
   runApiHandlerWithContext(event, async () => {
     try {
-      const { workspace: workspaceParam } = getQuery(event);
+      const { workspace: workspaceParam, cursor } = getQuery(event);
       const workspace = parseWorkspace(workspaceParam as string);
       const missing = await requireSlackCredential(event, workspace);
       if (missing) return missing;
-      const channels = await listChannels(workspace);
-      return { channels, total: channels.length };
+      const result = await listChannelsWithCoverage(
+        workspace,
+        cursor as string | undefined,
+      );
+      return {
+        channels: result.channels,
+        total: result.total,
+        truncated: result.truncated,
+        pagination: result.pagination,
+        coverage: result.coverage,
+      };
     } catch (err: any) {
       console.error("Slack channels error:", err.message);
       setResponseStatus(event, 500);
@@ -112,15 +121,33 @@ export const handleSlackHistory = defineEventHandler((event) =>
       const userIds = result.messages
         .map((m) => m.user)
         .filter((id): id is string => !!id);
-      const users = await resolveUsers(workspace, userIds, result.messages);
+      const resolution = await resolveUsersWithCoverage(
+        workspace,
+        userIds,
+        result.messages,
+      );
 
       const enrichedMessages = enrichMessages(result.messages);
 
       return {
         messages: enrichedMessages,
-        users,
+        users: resolution.users,
         has_more: result.has_more,
         next_cursor: result.next_cursor,
+        truncated: result.truncated,
+        pagination: result.pagination,
+        coverage: {
+          ...result.coverage,
+          coverage_complete:
+            result.coverage.coverage_complete &&
+            resolution.coverage.coverage_complete,
+          truncated: result.coverage.truncated || resolution.coverage.truncated,
+          truncation_reasons: [
+            ...result.coverage.truncation_reasons,
+            ...resolution.coverage.truncation_reasons,
+          ],
+          authors: resolution.coverage,
+        },
       };
     } catch (err: any) {
       console.error("Slack history error:", err.message);
@@ -165,29 +192,45 @@ export const handleSlackMultiHistory = defineEventHandler((event) =>
         ? JSON.parse(cursorsParam as string)
         : {};
 
-      // Fetch pageSize messages from each channel in parallel
-      const results = await Promise.all(
-        channelIds.map((id) =>
-          getChannelHistory(workspace, id, pageSize, cursors[id]),
+      // Fetch pageSize messages from each channel in parallel while preserving
+      // partial results when the bot is not invited to one of the channels.
+      const channelResults = await Promise.allSettled(
+        channelIds.map((channelId) =>
+          getChannelHistory(workspace, channelId, pageSize, cursors[channelId]),
         ),
       );
+      const successfulResults = channelResults.flatMap((entry, index) =>
+        entry.status === "fulfilled"
+          ? [{ channelId: channelIds[index], result: entry.value }]
+          : [],
+      );
+      const failedChannelIds = channelResults.flatMap((entry, index) =>
+        entry.status === "rejected" ? [channelIds[index]] : [],
+      );
 
       // Tag messages with channel name and merge
-      const allMessages: (SlackMessage & { channel_name: string })[] = [];
+      const allMessages: (SlackMessage & {
+        channel_id: string;
+        channel_name: string;
+      })[] = [];
       const perChannelHasMore: Record<string, boolean> = {};
       const nextCursors: Record<string, string> = {};
 
-      results.forEach((result, idx) => {
-        const chId = channelIds[idx];
-        const chName = channelNamesList[idx] || chId;
-        perChannelHasMore[chId] = result.has_more;
-        if (result.next_cursor) {
-          nextCursors[chId] = result.next_cursor;
-        }
-        for (const m of result.messages) {
-          allMessages.push({ ...m, channel_name: chName });
+      successfulResults.forEach(({ channelId, result }) => {
+        const chName =
+          channelNamesList[channelIds.indexOf(channelId)] || channelId;
+        perChannelHasMore[channelId] = result.has_more;
+        for (const message of result.messages) {
+          allMessages.push({
+            ...message,
+            channel_id: channelId,
+            channel_name: chName,
+          });
         }
       });
+      failedChannelIds.forEach((channelId) => {
+        perChannelHasMore[channelId] = true;
+      });
 
       // Sort merged by timestamp (newest first)
       allMessages.sort((a, b) => parseFloat(b.ts) - parseFloat(a.ts));
@@ -195,26 +238,112 @@ export const handleSlackMultiHistory = defineEventHandler((event) =>
       // Take top pageSize
       const pageMessages = allMessages.slice(0, pageSize);
 
+      const emittedByChannel = new Map<string, SlackMessage[]>();
+      for (const message of pageMessages) {
+        const emitted = emittedByChannel.get(message.channel_id) ?? [];
+        emitted.push(message);
+        emittedByChannel.set(message.channel_id, emitted);
+      }
+      for (const channelId of channelIds) {
+        const emitted = emittedByChannel.get(channelId);
+        const nextCursor = emitted?.[emitted.length - 1]?.ts;
+        if (nextCursor) nextCursors[channelId] = nextCursor;
+        else if (cursors[channelId])
+          nextCursors[channelId] = cursors[channelId];
+      }
+
       // Enrich text from blocks
-      const enrichedMessages = enrichMessages(pageMessages);
+      const enrichedMessages = pageMessages.map((message) => {
+        const enriched = enrichMessages([message])[0] ?? message;
+        const { channel_id: _channelId, ...rest } = enriched as typeof message;
+        return rest;
+      });
 
       // Resolve users
       const userIds = enrichedMessages
         .map((m) => m.user)
         .filter((id): id is string => !!id);
-      const users = await resolveUsers(workspace, userIds, enrichedMessages);
+      const resolution = await resolveUsersWithCoverage(
+        workspace,
+        userIds,
+        enrichedMessages,
+      );
 
       // has_more is true if any channel has more messages
+      const providerTruncated = successfulResults.some(
+        ({ result }) => result.truncated,
+      );
+      const mergedResultTruncated = allMessages.length > pageSize;
       const hasMore =
-        Object.values(perChannelHasMore).some(Boolean) ||
-        allMessages.length > pageSize;
+        providerTruncated ||
+        mergedResultTruncated ||
+        failedChannelIds.length > 0;
+      const truncationReasons = [
+        ...(providerTruncated ? ["provider_has_more"] : []),
+        ...(mergedResultTruncated ? ["merged_result_limit"] : []),
+        ...failedChannelIds.map(
+          (channelId) => `channel_fetch_failed:${channelId}`,
+        ),
+      ];
+      const channelPagination = Object.fromEntries(
+        channelResults.map((entry, index) => [
+          channelIds[index],
+          entry.status === "fulfilled"
+            ? entry.value.pagination
+            : {
+                cursor_type: "latest_ts" as const,
+                ...(cursors[channelIds[index]]
+                  ? { request_cursor: cursors[channelIds[index]] }
+                  : {}),
+              },
+        ]),
+      );
+      const channelCoverage = Object.fromEntries(
+        channelResults.map((entry, index) => [
+          channelIds[index],
+          entry.status === "fulfilled"
+            ? entry.value.coverage
+            : {
+                requested: pageSize,
+                fetched: 0,
+                returned: 0,
+                pages_fetched: 0,
+                coverage_complete: false,
+                truncated: true,
+                truncation_reasons: [
+                  `channel_fetch_failed:${channelIds[index]}`,
+                ],
+              },
+        ]),
+      );
 
       return {
         messages: enrichedMessages,
-        users,
+        users: resolution.users,
         has_more: hasMore,
         next_cursors: nextCursors,
         total: allMessages.length,
+        truncated: hasMore,
+        pagination: {
+          cursor_type: "per_channel_latest_ts",
+          request_cursors: cursors,
+          next_cursors: nextCursors,
+          channels: channelPagination,
+        },
+        coverage: {
+          requested: channelIds.length * pageSize,
+          fetched: allMessages.length,
+          returned: enrichedMessages.length,
+          pages_fetched: successfulResults.length,
+          coverage_complete: !hasMore && resolution.coverage.coverage_complete,
+          truncated: hasMore || resolution.coverage.truncated,
+          truncation_reasons: [
+            ...truncationReasons,
+            ...resolution.coverage.truncation_reasons,
+          ],
+          channels: channelCoverage,
+          authors: resolution.coverage,
+        },
       };
     } catch (err: any) {
       console.error("Slack multi-history error:", err.message);
@@ -242,9 +371,33 @@ export const handleSlackSearch = defineEventHandler((event) =>
       const userIds = result.messages
         .map((m) => m.user)
         .filter((id): id is string => !!id);
-      const users = await resolveUsers(workspace, userIds, result.messages);
+      const resolution = await resolveUsersWithCoverage(
+        workspace,
+        userIds,
+        result.messages,
+      );
 
-      return { messages: result.messages, users, total: result.total };
+      return {
+        messages: result.messages,
+        users: resolution.users,
+        total: result.total,
+        unsupported: result.unsupported,
+        guidance: result.guidance,
+        truncated: result.truncated,
+        pagination: result.pagination,
+        coverage: {
+          ...result.coverage,
+          coverage_complete:
+            result.coverage.coverage_complete &&
+            resolution.coverage.coverage_complete,
+          truncated: result.coverage.truncated || resolution.coverage.truncated,
+          truncation_reasons: [
+            ...result.coverage.truncation_reasons,
+            ...resolution.coverage.truncation_reasons,
+          ],
+          authors: resolution.coverage,
+        },
+      };
     } catch (err: any) {
       console.error("Slack search error:", err.message);
       setResponseStatus(event, 500);

package/corpus/templates/analytics/server/lib/agent-chat-plan-mode.ts

@@ -43,14 +43,9 @@ export const INITIAL_TOOL_NAMES = [
   "query-staged-dataset",
   "list-staged-datasets",
   "account-deep-dive",
-  "hubspot-deals",
-  "hubspot-records",
-  "hubspot-pipelines",
   "gong-calls",
+  "gong-native-insights",
   "github-repo-files",
-  "jira-search",
-  "slack-messages",
-  "sentry",
   "list-data-dictionary",
   "navigate",
 ];
@@ -66,6 +61,7 @@ export const PLAN_MODE_ACT_ONLY_TOOLS = new Set([
   "hubspot-records",
   "hubspot-pipelines",
   "gong-calls",
+  "gong-native-insights",
   "github-repo-files",
   "jira-search",
   "slack-messages",

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/db-admin-connections.ts

@@ -34,7 +34,7 @@ export interface DbAdminConnection {
   databaseAuthTokenLast4: string | null;
 }
 
-export interface DbAdminAdminContext {
+export interface AnalyticsAdminContext {
   userEmail: string;
   orgId: string;
   role: "owner" | "admin";
@@ -80,31 +80,39 @@ async function resolveOrgRole(
   }
 }
 
-export async function requireDbAdminContextFromRequest(input?: {
+export async function requireAnalyticsAdminContext(input?: {
   userEmail?: string;
   orgId?: string | null;
 }): Promise<DbAdminAdminContext> {
   const userEmail = input?.userEmail ?? getRequestUserEmail();
   const orgId = input?.orgId ?? getRequestOrgId() ?? null;
   if (!userEmail) {
-    throw new DbAdminConnectionError(401, "Sign in to manage app databases.");
+    throw new DbAdminConnectionError(
+      401,
+      "Sign in to use Analytics admin tools.",
+    );
   }
   if (!orgId) {
     throw new DbAdminConnectionError(
       403,
-      "An active organization is required to manage app databases.",
+      "An active organization is required to use Analytics admin tools.",
     );
   }
   const role = await resolveOrgRole(userEmail, orgId);
   if (!isAdminRole(role)) {
     throw new DbAdminConnectionError(
       403,
-      "Only organization owners and admins can access connected app databases.",
+      "Only organization owners and admins can use Analytics admin tools.",
     );
   }
   return { userEmail, orgId, role };
 }
 
+/** @deprecated Use requireAnalyticsAdminContext for Analytics admin surfaces. */
+export const requireDbAdminContextFromRequest = requireAnalyticsAdminContext;
+
+export type DbAdminAdminContext = AnalyticsAdminContext;
+
 export async function requireDbAdminContextFromEvent(
   event: H3Event,
 ): Promise<DbAdminAdminContext> {

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");
+}