@agent-native/core 0.99.3 → 0.100.1

package/corpus/templates/calendar/actions/list-events.ts

@@ -1,7 +1,11 @@
+import { createHash } from "node:crypto";
+
 import { defineAction } from "@agent-native/core";
 import {
   getRequestTimezone,
   getRequestUserEmail,
+  signShortLivedToken,
+  verifyShortLivedToken,
 } from "@agent-native/core/server";
 import { getUserSetting } from "@agent-native/core/settings";
 import { accessFilter } from "@agent-native/core/sharing";
@@ -44,6 +48,7 @@ async function fetchICalEventsCached(
     cal.color,
     from,
     to,
+    { throwOnError: true },
   );
   icalCache.set(cacheKey, { events, fetchedAt: Date.now() });
   return events;
@@ -60,14 +65,285 @@ interface ListCalendarEventsArgs {
   from?: string;
   to?: string;
   query?: string;
-  overlayEmails?: string;
+  overlayEmails?: string | string[];
+  accountEmails?: string[];
+  sources?: CalendarInventorySource[];
+  providerPageSize?: number;
+}
+
+interface ListCalendarEventsOptions {
+  ownedAccounts?: string[];
+  range?: CalendarEventRange;
 }
 
+type CalendarInventorySource = "google" | "bookings" | "ics" | "overlays";
+
 interface CalendarEventsResult {
   events: CalendarEvent[];
   errors: Array<{ email: string; error: string }>;
   googleConnected: boolean;
   range: CalendarEventRange;
+  icalErrors: Array<{ id: string; name: string; error: string }>;
+  icalSources: Array<{
+    id: string;
+    name: string;
+    status: "ok" | "error";
+    error?: string;
+  }>;
+  overlaySources: Array<{
+    email: string;
+    status: "ok" | "error";
+    error?: string;
+  }>;
+  requestedAccounts: string[] | null;
+  resolvedAccounts: string[];
+  queriedAccounts: string[];
+  sources: CalendarInventorySource[];
+}
+
+export interface CalendarInventoryItem {
+  key: string;
+  id: string;
+  title: string;
+  start: string;
+  end: string;
+  allDay: boolean;
+  eventType?: CalendarEvent["eventType"];
+  status?: CalendarEvent["status"];
+  transparency?: CalendarEvent["transparency"];
+  source: "google" | "booking" | "ics" | "overlay";
+  sourceId?: string;
+  accountEmail?: string;
+  overlayEmail?: string;
+  organizer?: { email?: string; displayName?: string; self?: boolean };
+  selfResponseStatus?: CalendarEvent["responseStatus"];
+  attendeeCount: number;
+  attendeeStatusCounts: Record<string, number>;
+  attendees: Array<{
+    email?: string;
+    displayName?: string;
+    responseStatus?: string;
+    optional?: boolean;
+    self?: boolean;
+    organizer?: boolean;
+  }>;
+  attendeesComplete: boolean;
+}
+
+interface InventoryCursor {
+  owner: string;
+  query: string;
+  start: string;
+  key: string;
+}
+
+const INVENTORY_VERSION = 1;
+const INVENTORY_CURSOR_PREFIX = "calendar-inventory:";
+const INVENTORY_PAGE_SIZE = 100;
+const INVENTORY_MAX_PAGE_SIZE = 250;
+const INVENTORY_ITEM_BUDGET_BYTES = 12_000;
+const INVENTORY_STRING_LIMIT = 240;
+const INVENTORY_ATTENDEE_PREVIEW_LIMIT = 8;
+
+function cap(
+  value: string | undefined,
+  limit = INVENTORY_STRING_LIMIT,
+): string | undefined {
+  if (!value) return undefined;
+  return value.length > limit ? `${value.slice(0, limit - 1)}…` : value;
+}
+
+function sanitizeError(message: unknown, fallback: string) {
+  return (
+    cap(
+      String(message ?? fallback)
+        .replace(/\bBearer\s+\S+/gi, "Bearer [redacted]")
+        .replace(
+          /\b(access_token|refresh_token|id_token|token)=([^\s&]+)/gi,
+          "$1=[redacted]",
+        ),
+    ) ?? fallback
+  );
+}
+
+function sourceCoverageError(message: string, fallback: string) {
+  const bounded = sanitizeError(message, fallback);
+  const notConnected = /not connected|reconnect|authentication/i.test(bounded);
+  return {
+    code: notConnected ? "NOT_CONNECTED" : "SOURCE_READ_FAILED",
+    message: bounded,
+    retryable: !notConnected,
+  };
+}
+
+function normalizedEmails(values: string[] | undefined): string[] {
+  return Array.from(
+    new Set(
+      (values ?? []).map((value) => value.trim().toLowerCase()).filter(Boolean),
+    ),
+  ).sort();
+}
+
+function mergeAccountErrors(
+  ...groups: Array<Array<{ email: string; error: string }>>
+): Array<{ email: string; error: string }> {
+  return Array.from(
+    new Map(
+      groups
+        .flat()
+        .map((entry) => [
+          `${entry.email.trim().toLowerCase()}\0${entry.error}`,
+          entry,
+        ]),
+    ).values(),
+  );
+}
+
+function normalizedOverlayEmails(value: string | string[] | undefined) {
+  return normalizedEmails(
+    Array.isArray(value)
+      ? value
+      : value?.split(",").map((email) => email.trim()),
+  );
+}
+
+function resolveInventorySources(
+  sources: CalendarInventorySource[] | undefined,
+): CalendarInventorySource[] {
+  return Array.from(
+    new Set<CalendarInventorySource>(
+      sources ?? ["google", "bookings", "ics", "overlays"],
+    ),
+  );
+}
+
+function inventoryQueryKey(args: {
+  from: string;
+  to: string;
+  query?: string;
+  accountEmails: string[];
+  overlayEmails?: string | string[];
+  sources: CalendarInventorySource[];
+}): string {
+  const canonical = JSON.stringify({
+    v: INVENTORY_VERSION,
+    from: args.from,
+    to: args.to,
+    query: args.query?.trim().toLowerCase() || "",
+    accountEmails: normalizedEmails(args.accountEmails),
+    overlayEmails: normalizedOverlayEmails(args.overlayEmails),
+    sources: [...args.sources].sort(),
+  });
+  return createHash("sha256").update(canonical).digest("base64url");
+}
+
+function encodeInventoryCursor(cursor: InventoryCursor): string {
+  const resourceId = `${INVENTORY_CURSOR_PREFIX}${Buffer.from(JSON.stringify(cursor)).toString("base64url")}`;
+  return signShortLivedToken({ resourceId, ttlSeconds: 600 });
+}
+
+function decodeInventoryCursor(
+  token: string,
+  owner: string,
+  query: string,
+): InventoryCursor {
+  const [payload] = token.split(".", 1);
+  if (!payload) throw new Error("Invalid inventory cursor");
+  let resourceId: unknown;
+  try {
+    resourceId = JSON.parse(
+      Buffer.from(payload, "base64url").toString("utf8"),
+    ).resourceId;
+  } catch {
+    throw new Error("Invalid inventory cursor");
+  }
+  if (
+    typeof resourceId !== "string" ||
+    !resourceId.startsWith(INVENTORY_CURSOR_PREFIX)
+  )
+    throw new Error("Invalid inventory cursor");
+  if (!verifyShortLivedToken(token, resourceId).ok)
+    throw new Error("Expired or invalid inventory cursor");
+  let cursor: InventoryCursor;
+  try {
+    cursor = JSON.parse(
+      Buffer.from(
+        resourceId.slice(INVENTORY_CURSOR_PREFIX.length),
+        "base64url",
+      ).toString("utf8"),
+    );
+  } catch {
+    throw new Error("Invalid inventory cursor");
+  }
+  if (
+    cursor.owner !== owner ||
+    cursor.query !== query ||
+    !cursor.start ||
+    !cursor.key
+  )
+    throw new Error("Inventory cursor does not match this query");
+  return cursor;
+}
+
+function compactInventoryEvent(event: CalendarEvent): CalendarInventoryItem {
+  const attendees = event.attendees ?? [];
+  const attendeeStatusCounts = attendees.reduce<Record<string, number>>(
+    (counts, attendee) => {
+      const status = attendee.responseStatus ?? "unknown";
+      counts[status] = (counts[status] ?? 0) + 1;
+      return counts;
+    },
+    {},
+  );
+  const key = [
+    event.source,
+    event.accountEmail ?? event.overlayEmail ?? "local",
+    event.googleEventId ?? event.id,
+    event.start,
+  ].join(":");
+  const source = event.overlayEmail
+    ? "overlay"
+    : event.source === "local"
+      ? "booking"
+      : event.source === "ical"
+        ? "ics"
+        : event.source;
+  return {
+    key,
+    id: event.googleEventId ?? event.id,
+    title: cap(event.title) ?? "Untitled",
+    start: event.start,
+    end: event.end,
+    allDay: event.allDay,
+    eventType: event.eventType,
+    status: event.status,
+    transparency: event.transparency,
+    source,
+    sourceId: event.sourceId,
+    accountEmail: event.accountEmail,
+    overlayEmail: event.overlayEmail,
+    organizer: event.organizer
+      ? {
+          email: cap(event.organizer.email, 320) ?? "",
+          displayName: cap(event.organizer.displayName),
+          self: event.organizer.self,
+        }
+      : undefined,
+    selfResponseStatus: event.responseStatus,
+    attendeeCount: attendees.length,
+    attendeeStatusCounts,
+    attendees: attendees
+      .slice(0, INVENTORY_ATTENDEE_PREVIEW_LIMIT)
+      .map((attendee) => ({
+        email: cap(attendee.email, 320) ?? "",
+        displayName: cap(attendee.displayName),
+        responseStatus: attendee.responseStatus,
+        optional: attendee.optional,
+        self: attendee.self,
+        organizer: attendee.organizer,
+      })),
+    attendeesComplete: attendees.length <= INVENTORY_ATTENDEE_PREVIEW_LIMIT,
+  };
 }
 
 function normalizeTimezone(timezone?: string): string {
@@ -298,66 +574,167 @@ function shouldShowLocalBookingEvent({
 
 export async function listCalendarEvents(
   args: ListCalendarEventsArgs = {},
+  options: ListCalendarEventsOptions = {},
 ): Promise<CalendarEventsResult> {
   const email = getRequestUserEmail();
   if (!email) throw new Error("no authenticated user");
-  const range = resolveCalendarEventRange({
-    from: args.from,
-    to: args.to,
-  });
+  const range =
+    options.range ??
+    resolveCalendarEventRange({
+      from: args.from,
+      to: args.to,
+    });
+
+  const sources = resolveInventorySources(args.sources);
+  const includeGoogle = sources.includes("google");
+  const includeOverlays = sources.includes("overlays");
 
-  // Fetch Google Calendar events
+  // Resolve owned accounts before any token refresh or provider call.
   let googleEvents: CalendarEvent[] = [];
   let errors: Array<{ email: string; error: string }> = [];
-  const connected = await googleCalendar.isConnected(email);
-  if (connected) {
-    const result = await googleCalendar.listEvents(range.from, range.to, email);
-    googleEvents = result.events;
-    errors = result.errors;
-
-    if (args.overlayEmails) {
-      const overlayEmails = args.overlayEmails
-        .split(",")
-        .filter(Boolean)
-        .slice(0, 10);
-      if (overlayEmails.length > 0) {
-        const { events: overlayEvents } =
-          await googleCalendar.listOverlayEvents(
-            range.from,
-            range.to,
-            overlayEmails,
-            email,
-          );
-        googleEvents = [...googleEvents, ...overlayEvents];
-      }
+  let overlaySources: Array<{
+    email: string;
+    status: "ok" | "error";
+    error?: string;
+  }> = [];
+  const normalizedRequestedAccounts = normalizedEmails(args.accountEmails);
+  const requestedAccounts = args.accountEmails
+    ? normalizedRequestedAccounts
+    : null;
+  let resolvedAccounts: string[] = [];
+  // Resolve/validate ownership before `isConnected` or token refreshes. A
+  // rejected filter is therefore atomic even when every token is expired.
+  const [ownedAccounts, connected] = await Promise.all([
+    options.ownedAccounts ?? googleCalendar.getOwnedAccountEmails(email),
+    googleCalendar.isConnected(email),
+  ]);
+  if (normalizedRequestedAccounts.length > 0) {
+    const unowned = normalizedRequestedAccounts.filter(
+      (account) =>
+        !ownedAccounts.some((owned) => owned.trim().toLowerCase() === account),
+    );
+    if (unowned.length > 0) {
+      throw new Error(
+        `Google Calendar account not connected for this user: ${unowned.join(", ")}`,
+      );
     }
+    resolvedAccounts = ownedAccounts.filter((account) =>
+      normalizedRequestedAccounts.includes(account.trim().toLowerCase()),
+    );
+  } else {
+    resolvedAccounts = ownedAccounts;
+  }
+  const requestedOverlayEmails = normalizedOverlayEmails(
+    args.overlayEmails,
+  ).slice(0, 10);
+  if (includeOverlays && requestedOverlayEmails.length > 0 && !connected) {
+    overlaySources = requestedOverlayEmails.map((overlayEmail) => ({
+      email: overlayEmail,
+      status: "error",
+      error: "Google Calendar is not connected",
+    }));
   }
+  // Once account ownership is validated, independent providers and local SQL
+  // can run together. The slowest source should set latency, not their sum.
+  const googleRead =
+    connected && includeGoogle
+      ? googleCalendar.listEvents(range.from, range.to, email, {
+          accountEmails: args.accountEmails,
+          maxResults: args.providerPageSize,
+        })
+      : Promise.resolve({ events: [], errors: [] });
+  const overlayRead =
+    connected && includeOverlays && requestedOverlayEmails.length > 0
+      ? googleCalendar.listOverlayEvents(
+          range.from,
+          range.to,
+          requestedOverlayEmails,
+          email,
+          { accountEmails: args.accountEmails },
+        )
+      : Promise.resolve({ events: [], errors: [], accountErrors: [] });
+  const icalRead = sources.includes("ics")
+    ? Promise.resolve(getUserSetting(email, "external-calendars")).then(
+        async (setting) => {
+          const calendars =
+            (setting as unknown as ExternalCalendar[] | null) ?? [];
+          return {
+            calendars,
+            results: await Promise.allSettled(
+              calendars.map((calendar) =>
+                fetchICalEventsCached(calendar, range.from, range.to),
+              ),
+            ),
+          };
+        },
+      )
+    : Promise.resolve({ calendars: [], results: [] });
+  const bookingRead = sources.includes("bookings")
+    ? listLocalBookingEvents(range.from, range.to)
+    : Promise.resolve([]);
 
-  // Fetch external ICS calendar feeds concurrently
-  const externalCalendars =
-    ((await getUserSetting(email, "external-calendars")) as unknown as
-      | ExternalCalendar[]
-      | null) ?? [];
+  const [googleResult, overlayResult, icalResult, rawBookingEvents] =
+    await Promise.all([googleRead, overlayRead, icalRead, bookingRead]);
+  googleEvents = [...googleResult.events, ...overlayResult.events];
+  errors = mergeAccountErrors(googleResult.errors, overlayResult.accountErrors);
+  if (connected && includeOverlays && requestedOverlayEmails.length > 0) {
+    overlaySources = requestedOverlayEmails.map((overlayEmail) => {
+      const error = overlayResult.errors.find(
+        (entry) => entry.email.toLowerCase() === overlayEmail.toLowerCase(),
+      );
+      return error
+        ? {
+            email: overlayEmail,
+            status: "error" as const,
+            error: error.error,
+          }
+        : { email: overlayEmail, status: "ok" as const };
+    });
+  }
 
-  const icalResults = await Promise.allSettled(
-    externalCalendars.map((cal) =>
-      fetchICalEventsCached(cal, range.from, range.to),
-    ),
-  );
+  const externalCalendars = icalResult.calendars;
+  const icalResults = icalResult.results;
 
   const icalEvents: CalendarEvent[] = icalResults.flatMap((r) =>
     r.status === "fulfilled" ? r.value : [],
   );
+  const icalErrors = icalResults.flatMap((result, index) =>
+    result.status === "rejected"
+      ? [
+          {
+            id: externalCalendars[index]!.id,
+            name: externalCalendars[index]!.name,
+            error:
+              result.reason instanceof Error
+                ? result.reason.message
+                : "Unable to load ICS feed",
+          },
+        ]
+      : [],
+  );
+  const icalSources = externalCalendars.map((calendar, index) => {
+    const result = icalResults[index]!;
+    return result.status === "fulfilled"
+      ? { id: calendar.id, name: calendar.name, status: "ok" as const }
+      : {
+          id: calendar.id,
+          name: calendar.name,
+          status: "error" as const,
+          error:
+            result.reason instanceof Error
+              ? result.reason.message
+              : "Unable to load ICS feed",
+        };
+  });
 
   const googleEventIds = new Set(
     googleEvents
       .map((event) => event.googleEventId)
       .filter((id): id is string => Boolean(id)),
   );
-  const googleReadAuthoritative = connected && errors.length === 0;
-  const bookingEvents = (
-    await listLocalBookingEvents(range.from, range.to)
-  ).filter((event) =>
+  const googleReadAuthoritative =
+    includeGoogle && connected && errors.length === 0;
+  const bookingEvents = rawBookingEvents.filter((event) =>
     shouldShowLocalBookingEvent({
       event,
       googleEventIds,
@@ -385,6 +762,16 @@ export async function listCalendarEvents(
     errors,
     googleConnected: connected,
     range,
+    icalErrors,
+    icalSources,
+    overlaySources,
+    requestedAccounts,
+    resolvedAccounts,
+    queriedAccounts:
+      includeGoogle || (includeOverlays && requestedOverlayEmails.length > 0)
+        ? resolvedAccounts
+        : [],
+    sources,
   };
 }
 
@@ -396,16 +783,244 @@ export default defineAction({
     to: z.string().optional().describe("End date (ISO string)"),
     query: z
       .string()
+      .max(500)
       .optional()
       .describe("Case-insensitive title/attendee/organizer search term"),
     overlayEmails: z
+      .union([z.string().max(3_200), z.array(z.string().email()).max(10)])
+      .optional()
+      .describe(
+        "Overlay calendar emails (an array, or legacy comma-separated string)",
+      ),
+    accountEmails: z
+      .array(z.string().email())
+      .min(1)
+      .max(20)
+      .optional()
+      .describe(
+        "Connected Google accounts to read; omitted reads every connected account",
+      ),
+    sources: z
+      .array(z.enum(["google", "bookings", "ics", "overlays"]))
+      .max(4)
+      .optional()
+      .describe("Calendar sources to query; omitted reads every source"),
+    format: z
+      .enum(["legacy", "inventory"])
+      .optional()
+      .describe("Use inventory for compact, coverage-aware external reads"),
+    cursor: z
       .string()
+      .max(4096)
       .optional()
-      .describe("Comma-separated emails for overlay calendar view"),
+      .describe("Opaque cursor from an inventory response"),
+    pageSize: z.coerce
+      .number()
+      .int()
+      .min(1)
+      .max(INVENTORY_MAX_PAGE_SIZE)
+      .optional(),
   }),
   http: { method: "GET" },
-  run: async (args) => {
-    const result = await listCalendarEvents(args);
+  readOnly: true,
+  publicAgent: { expose: true, readOnly: true, requiresAuth: true },
+  run: async (args, ctx) => {
+    const inventory =
+      args.format === "inventory" || (ctx?.caller === "mcp" && !args.format);
+    const owner = inventory ? getRequestUserEmail() : undefined;
+    if (inventory && !owner) throw new Error("no authenticated user");
+
+    // Reject invalid, expired, owner-bound, and query-bound cursors before any
+    // provider call. Omitted account filters require the cheap owned-account
+    // lookup to reproduce the exact query key, but token refreshes and calendar
+    // reads remain behind this gate.
+    let preparedCursor: InventoryCursor | undefined;
+    let preparedQuery: string | undefined;
+    let preparedRange: CalendarEventRange | undefined;
+    let preparedOwnedAccounts: string[] | undefined;
+    if (inventory && args.cursor) {
+      preparedRange = resolveCalendarEventRange({
+        from: args.from,
+        to: args.to,
+      });
+      preparedOwnedAccounts = args.accountEmails
+        ? undefined
+        : await googleCalendar.getOwnedAccountEmails(owner!);
+      preparedQuery = inventoryQueryKey({
+        from: preparedRange.from,
+        to: preparedRange.to,
+        query: args.query,
+        accountEmails: args.accountEmails ?? preparedOwnedAccounts ?? [],
+        overlayEmails: args.overlayEmails,
+        sources: resolveInventorySources(args.sources),
+      });
+      preparedCursor = decodeInventoryCursor(
+        args.cursor,
+        owner!,
+        preparedQuery,
+      );
+    }
+
+    const result = await listCalendarEvents(
+      {
+        ...args,
+      },
+      {
+        ownedAccounts: preparedOwnedAccounts,
+        range: preparedRange,
+      },
+    );
+
+    if (inventory) {
+      const query =
+        preparedQuery ??
+        inventoryQueryKey({
+          from: result.range.from,
+          to: result.range.to,
+          query: args.query,
+          accountEmails: result.requestedAccounts ?? result.resolvedAccounts,
+          overlayEmails: args.overlayEmails,
+          sources: result.sources,
+        });
+      const compact = result.events.map(compactInventoryEvent);
+      // Provider ids are only unique within an account. Prefer the owned Google
+      // occurrence to a duplicate local booking; otherwise keep first after a
+      // stable source/key sort.
+      const unique = Array.from(
+        new Map(
+          compact
+            .sort(
+              (a, b) =>
+                a.start.localeCompare(b.start) || a.key.localeCompare(b.key),
+            )
+            .map((item) => [item.key, item]),
+        ).values(),
+      );
+      const cursor = preparedCursor;
+      const afterCursor = cursor
+        ? unique.filter(
+            (item) =>
+              item.start > cursor.start ||
+              (item.start === cursor.start && item.key > cursor.key),
+          )
+        : unique;
+      const pageSize = args.pageSize ?? INVENTORY_PAGE_SIZE;
+      const items: CalendarInventoryItem[] = [];
+      for (const item of afterCursor) {
+        if (items.length >= pageSize) break;
+        const nextSize = Buffer.byteLength(
+          JSON.stringify([...items, item]),
+          "utf8",
+        );
+        if (items.length > 0 && nextSize > INVENTORY_ITEM_BUDGET_BYTES) break;
+        items.push(item);
+      }
+      const last = items[items.length - 1];
+      const hasMore = afterCursor.length > items.length;
+      const nextCursor =
+        hasMore && last
+          ? encodeInventoryCursor({
+              owner: owner!,
+              query,
+              start: last.start,
+              key: last.key,
+            })
+          : undefined;
+      const accounts = result.queriedAccounts.map((accountEmail) => {
+        const error = result.errors.find(
+          (entry) =>
+            entry.email.trim().toLowerCase() ===
+            accountEmail.trim().toLowerCase(),
+        );
+        return {
+          accountEmail,
+          status: error ? ("error" as const) : ("ok" as const),
+          count: compact.filter(
+            (item) => item.accountEmail?.trim().toLowerCase() === accountEmail,
+          ).length,
+          exhausted: !error,
+          ...(error
+            ? {
+                error: {
+                  code: "PROVIDER_READ_FAILED",
+                  message: sanitizeError(error.error, "Calendar read failed"),
+                  retryable: true,
+                },
+              }
+            : {}),
+        };
+      });
+      const sourceCoverage = [
+        ...(result.sources.includes("google") && !result.googleConnected
+          ? [
+              {
+                source: "google" as const,
+                id: "owned-accounts",
+                status: "error" as const,
+                error: {
+                  code: "NOT_CONNECTED",
+                  message: "Google Calendar is not connected",
+                  retryable: false,
+                },
+              },
+            ]
+          : []),
+        ...result.icalSources.map((feed) => ({
+          source: "ics" as const,
+          id: feed.id,
+          status: feed.status,
+          ...(feed.error
+            ? {
+                error: {
+                  ...sourceCoverageError(feed.error, "ICS read failed"),
+                },
+              }
+            : {}),
+        })),
+        ...result.overlaySources.map((overlay) => ({
+          source: "overlay" as const,
+          id: overlay.email,
+          status: overlay.status,
+          ...(overlay.error
+            ? {
+                error: {
+                  ...sourceCoverageError(overlay.error, "Overlay read failed"),
+                },
+              }
+            : {}),
+        })),
+        ...(result.sources.includes("bookings")
+          ? [
+              {
+                source: "booking" as const,
+                id: "bookings",
+                status: "ok" as const,
+              },
+            ]
+          : []),
+      ];
+      const coverageComplete =
+        accounts.every((account) => account.status === "ok") &&
+        sourceCoverage.every((entry) => entry.status === "ok");
+      return {
+        version: INVENTORY_VERSION,
+        query: {
+          ...result.range,
+          ...(args.query ? { text: args.query } : {}),
+          sources: result.sources,
+          overlayEmails: normalizedOverlayEmails(args.overlayEmails),
+        },
+        requestedAccounts: result.requestedAccounts,
+        resolvedAccounts: result.resolvedAccounts,
+        queriedAccounts: result.queriedAccounts,
+        accounts,
+        sourceCoverage,
+        coverageComplete,
+        complete: !hasMore && coverageComplete,
+        items,
+        page: { returned: items.length, nextCursor, hasMore },
+      };
+    }
 
     if (result.events.length === 0 && result.errors.length > 0) {
       throw new Error(