@agent-native/core 0.176.4 → 0.176.5-nightly-20260902205402

package/corpus/templates/calendar/app/pages/CalendarView.tsx

@@ -76,6 +76,7 @@ import {
   shouldShowEventsSkeleton,
 } from "@/hooks/use-events";
 import { useGoogleAuthStatus } from "@/hooks/use-google-auth";
+import { useGoogleCalendars } from "@/hooks/use-google-calendars";
 import { useMeetingStartNotifications } from "@/hooks/use-meeting-start-notifications";
 import { useIsMobile } from "@/hooks/use-mobile";
 import { useOverlayPeople } from "@/hooks/use-overlay-people";
@@ -439,6 +440,7 @@ export default function CalendarView() {
 
   const queryClient = useQueryClient();
   const googleStatus = useGoogleAuthStatus();
+  const googleCalendars = useGoogleCalendars();
   const defaultAccountEmail = googleStatus.data?.accounts?.[0]?.email;
   const settingsQuery = useSettings();
   const { data: settings } = settingsQuery;
@@ -455,6 +457,29 @@ export default function CalendarView() {
     () => overlayPeople.map((p) => p.email),
     [overlayPeople],
   );
+  const enabledGoogleCalendarSourceKeys = useMemo(() => {
+    if (!googleCalendars.enabled || !googleCalendars.data) return undefined;
+    return googleCalendars.data
+      .filter((source) => {
+        if (
+          hiddenCalendars.accounts.includes(source.accountEmail) ||
+          source.accessRole === "freeBusyReader"
+        ) {
+          return false;
+        }
+        if (source.primary) return true;
+        return (
+          viewPrefs.googleCalendarVisibility[source.sourceKey] ??
+          source.selected
+        );
+      })
+      .map((source) => source.sourceKey);
+  }, [
+    googleCalendars.data,
+    googleCalendars.enabled,
+    hiddenCalendars.accounts,
+    viewPrefs.googleCalendarVisibility,
+  ]);
   const createEvent = useCreateEvent();
   const updateEvent = useUpdateEvent();
   const deleteEvent = useDeleteEvent();
@@ -551,7 +576,7 @@ export default function CalendarView() {
     isLoading,
     isFetching,
     isPlaceholderData,
-  } = useEvents(from, to, overlayEmails);
+  } = useEvents(from, to, overlayEmails, enabledGoogleCalendarSourceKeys);
   const rawEvents = Array.isArray(rawEventsData) ? rawEventsData : [];
   const draftEvent = useMemo(
     () => (eventDraft ? draftToCalendarEvent(eventDraft, selectedDate) : null),
@@ -619,10 +644,17 @@ export default function CalendarView() {
       }
     })();
     for (const range of ranges) {
-      void prefetchEvents(queryClient, range.from, range.to, overlayEmails);
+      void prefetchEvents(
+        queryClient,
+        range.from,
+        range.to,
+        overlayEmails,
+        enabledGoogleCalendarSourceKeys,
+      );
     }
   }, [
     displayTimezone,
+    enabledGoogleCalendarSourceKeys,
     isLoading,
     overlayEmails,
     queryClient,
@@ -1085,6 +1117,7 @@ export default function CalendarView() {
         notificationMessage?: string;
       },
     ) => {
+      if (ev.calendarPrimary === false || ev.calendarReadOnly) return;
       const isOrganizer = isCalendarEventOrganizer(ev);
       const hasOtherAttendees =
         ev.attendees && ev.attendees.filter((a) => !a.self).length > 0;
@@ -1167,7 +1200,7 @@ export default function CalendarView() {
         return;
       }
       const ev = events.find((e) => e.id === eventId);
-      if (!ev) return;
+      if (!ev || ev.calendarPrimary === false || ev.calendarReadOnly) return;
       const isRecurring = !!(ev.recurringEventId || ev.recurrence?.length);
       const isOrganizer = isCalendarEventOrganizer(ev);
       const hasOtherAttendees =
@@ -1185,7 +1218,13 @@ export default function CalendarView() {
   // Move event to a new date (drag-and-drop from MonthView)
   async function handleEventDrop(eventId: string, newDate: Date) {
     const event = events.find((e) => e.id === eventId);
-    if (!event || !isCalendarEventOrganizer(event) || updateEvent.isPending)
+    if (
+      !event ||
+      event.calendarPrimary === false ||
+      event.calendarReadOnly ||
+      !isCalendarEventOrganizer(event) ||
+      updateEvent.isPending
+    )
       return;
 
     const moved = moveEventToCalendarDate(event, newDate, displayTimezone);
@@ -1258,7 +1297,13 @@ export default function CalendarView() {
     async (eventId: string, newStart: Date, newEnd: Date) => {
       // Skip no-op drags (dropped back in same spot)
       const event = events.find((e) => e.id === eventId);
-      if (!event || !isCalendarEventOrganizer(event) || updateEvent.isPending)
+      if (
+        !event ||
+        event.calendarPrimary === false ||
+        event.calendarReadOnly ||
+        !isCalendarEventOrganizer(event) ||
+        updateEvent.isPending
+      )
         return;
 
       // Guard against a zero/negative duration reaching the server —

package/corpus/templates/calendar/changelog/2026-09-01-calendars-shared-with-your-connected-google-accounts-can-now.md

@@ -0,0 +1,6 @@
+---
+type: added
+date: 2026-09-01
+---
+
+Calendars shared with your connected Google accounts can now appear alongside your primary calendars.

package/corpus/templates/calendar/changelog/2026-09-02-updated-the-booking-link-og-preview-image-with-the-new-monoc.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-09-02
+---
+
+Updated the booking-link OG preview image with the new monochrome logo and dark background.

package/corpus/templates/calendar/server/lib/booking-og-image.ts

@@ -16,13 +16,11 @@ export interface BookingOgImageInput {
 
 const WIDTH = 1200;
 const HEIGHT = 630;
-const BRAND_BLUE = "#00B5FF";
-const BRAND_MINT = "#48FFE4";
-const BG = "#000000";
+const BG = "#0A0A0A";
 const SURFACE = "#0a0a0a";
 const BORDER = "#1f1f1f";
-const FG = "#ededed";
-const MUTED = "#a0a0a0";
+const FG = "#FAF9F5";
+const MUTED = "#9A9997";
 const FONT_FAMILY = "Liberation Sans, Arial, system-ui, sans-serif";
 const FONT_SOURCE_PATHS = [
   "../../assets/fonts/LiberationSans-Regular.ttf",
@@ -33,8 +31,8 @@ const AVATAR_CY = 170;
 const AVATAR_SIZE = 172;
 
 const LOGO_MARK = `
-  <path d="M24.5537 65.7695H0L15.0859 39.4619L37.708 0L60.4912 39.4619H39.6396L24.5537 65.7695Z" fill="white"/>
-  <path d="M89.446 0H114L76.2921 65.7704H51.7383L89.446 0Z" fill="url(#brand)"/>
+  <path d="M26.8789 71.999H0L16.5146 43.1992L41.2793 0L66.2197 43.1992H43.3945L26.8789 71.999Z" fill="white"/>
+  <path d="M97.914 0H124.794L83.5143 72H56.6348L97.914 0Z" fill="white"/>
 `;
 
 function escapeSvg(value: string): string {
@@ -239,34 +237,26 @@ export function renderBookingOgImageSvg(input: BookingOgImageInput): string {
     titleLines.length === 1
       ? `<g transform="translate(0 150)">
       <rect x="0" y="-34" width="${Math.max(246, duration.length * 17 + 54)}" height="58" rx="29" fill="${SURFACE}" stroke="${BORDER}"/>
-      <circle cx="31" cy="-5" r="8" fill="${BRAND_MINT}"/>
+      <circle cx="31" cy="-5" r="8" fill="${FG}"/>
       <text x="54" y="4" font-family="${FONT_FAMILY}" font-size="27" font-weight="700" fill="${FG}">${escapeSvg(duration)}</text>
     </g>`
       : "";
   const avatarContent = profileImageDataUrl
     ? `<image x="${AVATAR_CX - AVATAR_SIZE / 2}" y="${AVATAR_CY - AVATAR_SIZE / 2}" width="${AVATAR_SIZE}" height="${AVATAR_SIZE}" href="${escapeSvg(profileImageDataUrl)}" preserveAspectRatio="xMidYMid slice" mask="url(#avatarMask)"/>`
-    : `<circle cx="${AVATAR_CX}" cy="${AVATAR_CY}" r="72" fill="url(#brand)" fill-opacity="0.2"/>
+    : `<circle cx="${AVATAR_CX}" cy="${AVATAR_CY}" r="72" fill="${FG}" fill-opacity="0.12"/>
        <text x="${AVATAR_CX}" y="${AVATAR_CY + 20}" text-anchor="middle" font-family="${FONT_FAMILY}" font-size="56" font-weight="800" fill="${FG}">${escapeSvg(initials)}</text>`;
 
   return `<svg xmlns="http://www.w3.org/2000/svg" width="${WIDTH}" height="${HEIGHT}" viewBox="0 0 ${WIDTH} ${HEIGHT}">
   <title>Agent-Native Calendar booking link</title>
   <defs>
-    <linearGradient id="brand" x1="101.702" y1="67.4791" x2="113.672" y2="-37.4275" gradientUnits="userSpaceOnUse">
-      <stop stop-color="${BRAND_BLUE}"/>
-      <stop offset="1" stop-color="${BRAND_MINT}"/>
-    </linearGradient>
-    <pattern id="grid" width="48" height="48" patternUnits="userSpaceOnUse">
-      <path d="M 48 0 L 0 0 0 48" fill="none" stroke="#ffffff" stroke-opacity="0.07" stroke-width="1"/>
-    </pattern>
     <mask id="avatarMask">
       <rect width="${WIDTH}" height="${HEIGHT}" fill="black"/>
       <circle cx="${AVATAR_CX}" cy="${AVATAR_CY}" r="78" fill="white"/>
     </mask>
   </defs>
   <rect width="${WIDTH}" height="${HEIGHT}" fill="${BG}"/>
-  <rect width="${WIDTH}" height="${HEIGHT}" fill="url(#grid)"/>
   <g transform="translate(80 86)">
-    <g transform="scale(0.62)">
+    <g transform="translate(0 14) scale(0.62)">
       ${LOGO_MARK}
     </g>
     <text x="90" y="31" font-family="${FONT_FAMILY}" font-size="28" font-weight="800" fill="${FG}">Agent-Native</text>

package/corpus/templates/calendar/server/lib/google-api.ts

@@ -385,6 +385,16 @@ export function calendarListEvents(
   );
 }
 
+export function calendarListCalendars(
+  accessToken: string,
+  params: { maxResults?: number; pageToken?: string } = {},
+) {
+  return googleFetch(
+    `${CALENDAR_BASE}/users/me/calendarList${qs(params)}`,
+    accessToken,
+  );
+}
+
 export function calendarGetCalendar(accessToken: string, calendarId: string) {
   return googleFetch(
     `${CALENDAR_BASE}/calendars/${encodeURIComponent(calendarId)}`,

package/corpus/templates/calendar/server/lib/google-calendar.ts

@@ -17,15 +17,21 @@ import { resolveWorkspaceConnectionForApp } from "@agent-native/core/workspace-c
 
 import type {
   CalendarEvent,
+  GoogleCalendarSource,
   GoogleAuthStatus,
   UpdateEventScope,
 } from "../../shared/api.js";
+import {
+  createGoogleCalendarSourceKey,
+  parseGoogleCalendarSourceKey,
+} from "../../shared/google-calendar-sources.js";
 import { getGoogleEventColorHex } from "../../shared/google-event-colors.js";
 import { isCalendarTimezone } from "../../shared/timezone.js";
 import {
   createOAuth2Client,
   oauth2GetUserInfo,
   calendarListEvents,
+  calendarListCalendars,
   calendarFreeBusy,
   calendarGetCalendar,
   calendarGetEvent,
@@ -1050,6 +1056,77 @@ export async function getClientsForAccountsWithErrors(
   };
 }
 
+function asCalendarAccessRole(
+  value: unknown,
+): GoogleCalendarSource["accessRole"] {
+  return value === "freeBusyReader" ||
+    value === "reader" ||
+    value === "writer" ||
+    value === "owner"
+    ? value
+    : "reader";
+}
+
+/** Discover every CalendarList entry visible to each connected Google account. */
+export async function listGoogleCalendars(forEmail?: string): Promise<{
+  calendars: GoogleCalendarSource[];
+  errors: Array<{ email: string; error: string }>;
+}> {
+  const { clients, errors: refreshErrors } =
+    await getClientsForAccountsWithErrors(forEmail);
+  const errors = [...refreshErrors];
+  const results = await mapWithConcurrency(clients, async (client) => {
+    try {
+      const items: any[] = [];
+      let pageToken: string | undefined;
+      do {
+        const response = await calendarListCalendars(client.accessToken, {
+          maxResults: 250,
+          pageToken,
+        });
+        items.push(...(response.items ?? []));
+        pageToken =
+          typeof response.nextPageToken === "string"
+            ? response.nextPageToken
+            : undefined;
+      } while (pageToken);
+      return items
+        .filter((item) => typeof item.id === "string" && item.id.length > 0)
+        .map((item): GoogleCalendarSource => {
+          const accessRole = asCalendarAccessRole(item.accessRole);
+          return {
+            sourceKey: createGoogleCalendarSourceKey({
+              accountEmail: client.email,
+              calendarId: item.id,
+            }),
+            accountEmail: client.email,
+            calendarId: item.id,
+            name: item.summaryOverride || item.summary || item.id,
+            color: item.backgroundColor || undefined,
+            selected: item.selected === true,
+            primary: item.primary === true,
+            accessRole,
+            readOnly:
+              item.primary !== true ||
+              (accessRole !== "owner" && accessRole !== "writer"),
+          };
+        });
+    } catch (error: any) {
+      errors.push({
+        email: client.email,
+        error: error?.message || "Unable to list Google calendars",
+      });
+      return [];
+    }
+  });
+  return {
+    calendars: results
+      .flat()
+      .sort((a, b) => a.sourceKey.localeCompare(b.sourceKey)),
+    errors: errors.sort((a, b) => a.email.localeCompare(b.email)),
+  };
+}
+
 export async function isConnected(forEmail?: string): Promise<boolean> {
   if (!forEmail) return false;
   const accounts = await listOAuthAccountsByOwner("google", forEmail);
@@ -1172,7 +1249,11 @@ export async function listEvents(
   timeMin: string,
   timeMax: string,
   forEmail?: string,
-  options: { accountEmails?: string[]; maxResults?: number } = {},
+  options: {
+    accountEmails?: string[];
+    calendarSourceKeys?: string[];
+    maxResults?: number;
+  } = {},
 ): Promise<{
   events: CalendarEvent[];
   errors: Array<{ email: string; error: string }>;
@@ -1186,36 +1267,115 @@ export async function listEvents(
   const errors: Array<{ email: string; error: string }> = [...refreshErrors];
   if (clients.length === 0) return { events: [], errors };
 
+  const requestedSourceKeys = Array.from(
+    new Set((options.calendarSourceKeys ?? []).filter(Boolean)),
+  );
+  let selectedSourcesByAccount = new Map<string, GoogleCalendarSource[]>();
+  if (requestedSourceKeys.length > 0) {
+    const discovered = await listGoogleCalendars(forEmail);
+    errors.push(...discovered.errors);
+    const discoveredByKey = new Map(
+      discovered.calendars.map((source) => [source.sourceKey, source]),
+    );
+    const invalid = requestedSourceKeys.filter((sourceKey) => {
+      const identity = parseGoogleCalendarSourceKey(sourceKey);
+      return !identity || !discoveredByKey.has(sourceKey);
+    });
+    if (invalid.length > 0) {
+      throw new Error(
+        `Google Calendar source is not connected or no longer available: ${invalid.join(", ")}`,
+      );
+    }
+    for (const sourceKey of requestedSourceKeys) {
+      const source = discoveredByKey.get(sourceKey)!;
+      const accountKey = source.accountEmail.trim().toLowerCase();
+      selectedSourcesByAccount.set(accountKey, [
+        ...(selectedSourcesByAccount.get(accountKey) ?? []),
+        source,
+      ]);
+    }
+    const availableAccounts = new Set(
+      clients.map((client) => client.email.trim().toLowerCase()),
+    );
+    const excluded = Array.from(selectedSourcesByAccount.keys()).filter(
+      (accountEmail) => !availableAccounts.has(accountEmail),
+    );
+    if (excluded.length > 0) {
+      throw new Error(
+        `Google Calendar source account was not selected: ${excluded.join(", ")}`,
+      );
+    }
+  }
+
   const allResults = await mapWithConcurrency(
     clients,
     async ({ email, accessToken }) => {
       try {
+        const sources = selectedSourcesByAccount.size
+          ? (selectedSourcesByAccount.get(email.trim().toLowerCase()) ?? [])
+          : [undefined];
         const events: any[] = [];
-        let pageToken: string | undefined;
-        do {
-          const response = await calendarListEvents(accessToken, "primary", {
-            timeMin,
-            timeMax,
-            singleEvents: true,
-            orderBy: "startTime",
-            maxResults: options.maxResults ?? 2500,
-            pageToken,
-            eventTypes: LIST_EVENT_TYPES,
-          });
-          events.push(...(response.items || []));
-          pageToken =
-            typeof response.nextPageToken === "string"
-              ? response.nextPageToken
-              : undefined;
-        } while (pageToken);
+        for (const source of sources) {
+          if (source?.accessRole === "freeBusyReader") {
+            errors.push({
+              email,
+              error: `Google Calendar source ${source.name} (${source.calendarId}) only grants free/busy access; detailed events were not read`,
+            });
+            continue;
+          }
+          try {
+            let pageToken: string | undefined;
+            do {
+              const response = await calendarListEvents(
+                accessToken,
+                source?.calendarId ?? "primary",
+                {
+                  timeMin,
+                  timeMax,
+                  singleEvents: true,
+                  orderBy: "startTime",
+                  maxResults: options.maxResults ?? 2500,
+                  pageToken,
+                  eventTypes: LIST_EVENT_TYPES,
+                },
+              );
+              events.push(
+                ...(response.items || []).map((event: any) => ({
+                  ...event,
+                  __calendarSource: source,
+                })),
+              );
+              pageToken =
+                typeof response.nextPageToken === "string"
+                  ? response.nextPageToken
+                  : undefined;
+            } while (pageToken);
+          } catch (error: any) {
+            errors.push({
+              email,
+              error: source
+                ? `Unable to read Google Calendar source ${source.name} (${source.calendarId}): ${error?.message || "Unknown provider error"}`
+                : error?.message || "Unable to load Google Calendar events",
+            });
+          }
+        }
 
         return events.map((event: any) => {
+          const calendarSource = event.__calendarSource as
+            | GoogleCalendarSource
+            | undefined;
           // Find the current user's RSVP status from attendees
           const selfAttendee = event.attendees?.find(
             (a: any) => a.self === true,
           );
           return {
-            id: `google-${event.id}`,
+            // Google event ids are only unique within a calendar. Retain the
+            // primary legacy id while namespacing every selected non-primary
+            // source so client keys and mutations cannot collide.
+            id:
+              calendarSource && !calendarSource.primary
+                ? `google-${calendarSource.sourceKey}-${event.id}`
+                : `google-${event.id}`,
             title: event.summary || "Untitled",
             titleIsGenerated: !event.summary,
             description: event.description || "",
@@ -1229,6 +1389,12 @@ export async function listEvents(
             googleEventId: event.id || undefined,
             htmlLink: event.htmlLink || undefined,
             accountEmail: email,
+            calendarSourceKey: calendarSource?.sourceKey,
+            calendarId: calendarSource?.calendarId,
+            calendarName: calendarSource?.name,
+            calendarAccessRole: calendarSource?.accessRole,
+            calendarPrimary: calendarSource?.primary,
+            calendarReadOnly: calendarSource?.readOnly,
             responseStatus: selfAttendee?.responseStatus,
             transparency: event.transparency || undefined,
             ...mapColor(event),
@@ -1500,18 +1666,40 @@ export async function listOverlayEvents(
 export async function getEvent(
   googleEventId: string,
   account: GoogleAccountSelection,
+  options: { calendarSourceKey?: string } = {},
 ): Promise<CalendarEvent> {
+  let calendarSource: GoogleCalendarSource | undefined;
+  if (options.calendarSourceKey) {
+    const discovered = await listGoogleCalendars(account.ownerEmail);
+    calendarSource = discovered.calendars.find(
+      (source) => source.sourceKey === options.calendarSourceKey,
+    );
+    if (
+      !calendarSource ||
+      calendarSource.accountEmail.trim().toLowerCase() !==
+        account.accountEmail.trim().toLowerCase()
+    ) {
+      throw new Error(
+        "Google Calendar source is not connected or no longer available",
+      );
+    }
+    if (calendarSource.accessRole === "freeBusyReader") {
+      throw new Error("Google Calendar source only grants free/busy access");
+    }
+  }
   const client = await getClientForAccount(account);
 
   const event = await calendarGetEvent(
     client.accessToken,
-    "primary",
+    calendarSource?.calendarId ?? "primary",
     googleEventId,
   );
   const selfAttendee = event.attendees?.find((a: any) => a.self === true);
 
   return {
-    id: `google-${event.id}`,
+    id: calendarSource
+      ? `google-${calendarSource.sourceKey}-${event.id}`
+      : `google-${event.id}`,
     title: event.summary || "Untitled",
     titleIsGenerated: !event.summary,
     description: event.description || "",
@@ -1525,6 +1713,12 @@ export async function getEvent(
     googleEventId: event.id || undefined,
     htmlLink: event.htmlLink || undefined,
     accountEmail: account.accountEmail,
+    calendarSourceKey: calendarSource?.sourceKey,
+    calendarId: calendarSource?.calendarId,
+    calendarName: calendarSource?.name,
+    calendarAccessRole: calendarSource?.accessRole,
+    calendarPrimary: calendarSource?.primary,
+    calendarReadOnly: calendarSource?.readOnly,
     responseStatus: selfAttendee?.responseStatus || undefined,
     transparency: event.transparency || undefined,
     ...mapColor(event),

package/corpus/templates/calendar/server/plugins/agent-chat.ts

@@ -62,6 +62,7 @@ registerEvent({
 
 const INITIAL_TOOL_NAMES = [
   "view-screen",
+  "list-google-calendars",
   "list-events",
   "search-events",
   "get-event",
@@ -113,6 +114,7 @@ Google Calendar events are NOT stored in the local database. They are fetched li
 Provider-specific Calendar actions are shortcuts, not limits. If a first-class action cannot express the exact Google Calendar/CRM endpoint, calendar id, filter, request body, pagination mode, attendee search, recurrence field, or API version needed, call \`provider-api-catalog\` and \`provider-api-docs\` as needed, then call \`provider-api-request\` against the provider's real HTTP API. Use this raw provider API escape hatch instead of weakening the answer, broadening filters, or claiming Calendar cannot do something the underlying API can do.
 
 - \`pnpm action view-screen\` — See the visible UI state (current view, date, selected event). Use it for questions about what the user is looking at, not as a prerequisite for deterministic schedule reads.
+- \`pnpm action list-google-calendars\` — Discover the primary and shared calendars available through every connected Google account. Pass returned opaque \`sourceKey\` values to \`list-events --calendarSourceKeys '[...]'\`; shared calendars are view-only and excluded from booking availability.
 - \`pnpm action list-events --from YYYY-MM-DD --to YYYY-MM-DD\` — List events from Google Calendar. The --to date is exclusive, so use tomorrow for today's events.
 - \`pnpm action search-events --query "term" --from YYYY-MM-DD --to YYYY-MM-DD\` — Convenience bounded search by title, attendees, organizer, location, or description. For relationship history, all-calendar discovery, exact attendee/domain search, or custom pagination, prefer provider-api-request with provider=google_calendar.
 - \`pnpm action provider-api-catalog\` / \`provider-api-docs\` / \`provider-api-request\` — Inspect and call the real Google Calendar, Apollo, Gong, HubSpot, and Pylon APIs directly. For Google Calendar events.list pagination use provider=google_calendar, path=/calendars/primary/events, query={...}, fetchAllPages={cursorPath:"nextPageToken",cursorParam:"pageToken",itemsPath:"items"}. For large relationship-history scans, pass stageAs and pagination={nextCursorPath:"nextPageToken",cursorParam:"pageToken",maxPages:N} with itemsPath="items", then use query-staged-dataset.

package/corpus/templates/calendar/server/plugins/feature-flags.ts

@@ -0,0 +1,5 @@
+import { createFeatureFlagsPlugin } from "@agent-native/core/server";
+
+import { SHARED_GOOGLE_CALENDARS } from "../../shared/feature-flags.js";
+
+export default createFeatureFlagsPlugin({ flags: [SHARED_GOOGLE_CALENDARS] });

package/corpus/templates/calendar/shared/api.ts

@@ -19,6 +19,13 @@ export interface CalendarEvent {
   /** Absolute Google Calendar web URL for Google events */
   htmlLink?: string;
   accountEmail?: string;
+  /** Provenance for a discovered Google calendar source. */
+  calendarSourceKey?: string;
+  calendarId?: string;
+  calendarName?: string;
+  calendarAccessRole?: GoogleCalendarSource["accessRole"];
+  calendarPrimary?: boolean;
+  calendarReadOnly?: boolean;
   /** Set when this event belongs to an overlaid person's calendar */
   overlayEmail?: string;
   /** Client-only marker for overlaid calendar ownership */
@@ -360,6 +367,19 @@ export interface GoogleAuthStatus {
   }>;
 }
 
+export interface GoogleCalendarSource {
+  sourceKey: string;
+  accountEmail: string;
+  calendarId: string;
+  name: string;
+  color?: string;
+  selected: boolean;
+  primary: boolean;
+  accessRole: "freeBusyReader" | "reader" | "writer" | "owner";
+  /** Sources without event detail access are discoverable but cannot be read. */
+  readOnly: boolean;
+}
+
 export interface ExternalCalendar {
   id: string;
   name: string;

package/corpus/templates/calendar/shared/calendar-view-preferences.ts

@@ -29,6 +29,8 @@ export interface CalendarViewPreferences {
   accountColorModes: Record<CalendarColorSourceKey, CalendarColorMode>;
   /** Per-account fixed color, used when that account's mode is "single" */
   accountColors: Record<CalendarColorSourceKey, string>;
+  /** Agent-Native visibility overrides for Google calendar sources. */
+  googleCalendarVisibility: Record<string, boolean>;
 }
 
 export const DEFAULT_CALENDAR_VIEW_PREFERENCES: CalendarViewPreferences = {
@@ -37,6 +39,7 @@ export const DEFAULT_CALENDAR_VIEW_PREFERENCES: CalendarViewPreferences = {
   singleColor: CALENDAR_COLORS[0],
   accountColorModes: {},
   accountColors: {},
+  googleCalendarVisibility: {},
 };
 
 export function isValidCalendarColorMode(
@@ -71,6 +74,15 @@ function normalizeColorRecord(
   return out;
 }
 
+function normalizeBooleanRecord(input: unknown): Record<string, boolean> {
+  const out: Record<string, boolean> = {};
+  if (!input || typeof input !== "object") return out;
+  for (const [key, value] of Object.entries(input as Record<string, unknown>)) {
+    if (typeof value === "boolean") out[key] = value;
+  }
+  return out;
+}
+
 /**
  * Returns a stable default color for an account that hasn't picked one yet,
  * cycling through the shared palette by the account's position in `keys` so
@@ -91,6 +103,7 @@ export function normalizeCalendarViewPreferences(
     ...DEFAULT_CALENDAR_VIEW_PREFERENCES,
     accountColorModes: {},
     accountColors: {},
+    googleCalendarVisibility: {},
   };
   if (!input || typeof input !== "object") return next;
 
@@ -105,6 +118,9 @@ export function normalizeCalendarViewPreferences(
   }
   next.accountColorModes = normalizeColorModeRecord(input.accountColorModes);
   next.accountColors = normalizeColorRecord(input.accountColors);
+  next.googleCalendarVisibility = normalizeBooleanRecord(
+    input.googleCalendarVisibility,
+  );
   return next;
 }
 
@@ -117,10 +133,21 @@ export function calendarViewPreferencesEqual(
     a.colorMode === b.colorMode &&
     a.singleColor === b.singleColor &&
     recordsEqual(a.accountColorModes, b.accountColorModes) &&
-    recordsEqual(a.accountColors, b.accountColors)
+    recordsEqual(a.accountColors, b.accountColors) &&
+    booleanRecordsEqual(a.googleCalendarVisibility, b.googleCalendarVisibility)
   );
 }
 
+function booleanRecordsEqual(
+  a: Record<string, boolean>,
+  b: Record<string, boolean>,
+): boolean {
+  const aKeys = Object.keys(a);
+  const bKeys = Object.keys(b);
+  if (aKeys.length !== bKeys.length) return false;
+  return aKeys.every((key) => a[key] === b[key]);
+}
+
 function recordsEqual(
   a: Record<string, string>,
   b: Record<string, string>,

package/corpus/templates/calendar/shared/feature-flags.ts

@@ -0,0 +1,8 @@
+import { defineFeatureFlag } from "@agent-native/core/feature-flags/registry";
+
+export const SHARED_GOOGLE_CALENDARS = defineFeatureFlag({
+  key: "shared-google-calendars",
+  displayName: "Shared Google calendars",
+  description:
+    "Display non-primary calendars available through connected Google accounts.",
+});