@agent-native/core 0.185.0 → 0.186.0-nightly-20260923174435

package/corpus/README.md

@@ -31,4 +31,4 @@ rg -n "defineAction|useActionQuery" node_modules/@agent-native/core/corpus
 
 ## Generated Counts
 
-- template files: 9786
+- template files: 9788

package/corpus/templates/calendar/actions/delete-event.ts

@@ -9,9 +9,11 @@ import { isGoogleEventAbsentError } from "../server/lib/google-api.js";
 import * as googleCalendar from "../server/lib/google-calendar.js";
 import {
   cliBoolean,
+  googleEventResultId,
   normalizeWritableGoogleEventId,
   rawCliBoolean,
   requireActionUserEmail,
+  resolveGoogleEventAccountEmail,
   resolveOwnedAccountEmail,
 } from "./event-action-helpers.js";
 
@@ -66,11 +68,11 @@ export default defineAction({
       );
     }
 
-    const googleEventId = normalizeWritableGoogleEventId(args.id);
     const accountEmail = await resolveOwnedAccountEmail(
-      args.accountEmail,
+      resolveGoogleEventAccountEmail(args.id, args.accountEmail),
       ownerEmail,
     );
+    const googleEventId = normalizeWritableGoogleEventId(args.id);
     const guestNotificationMessage = normalizeGuestNotificationMessage(
       args.notificationMessage,
     );
@@ -109,7 +111,7 @@ export default defineAction({
       return {
         success: true,
         alreadyAbsent: true,
-        id: `google-${googleEventId}`,
+        id: googleEventResultId(args.id, googleEventId, accountEmail),
         accountEmail,
         scope: args.scope,
         removedOnly: args.removeOnly ?? false,
@@ -130,7 +132,7 @@ export default defineAction({
     return {
       success: true,
       alreadyAbsent: false,
-      id: `google-${googleEventId}`,
+      id: googleEventResultId(args.id, googleEventId, accountEmail),
       accountEmail,
       scope: args.scope,
       removedOnly: args.removeOnly ?? false,

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

@@ -15,12 +15,14 @@ import {
   BULK_EVENT_CONCURRENCY,
   MAX_MATCHED_EVENTS,
   cliBoolean,
+  googleEventResultId,
   isBookedOnAccount,
   mapWithConcurrency,
   normalizeWritableGoogleEventId,
   rawCliBoolean,
   requireActionUserEmail,
   requireExplicitBound,
+  resolveBulkGoogleEventAccountEmail,
   resolveOwnedAccountEmail,
   startsWithinRange,
   undeletableEventReason,
@@ -218,22 +220,24 @@ export default defineAction({
 
     if (hasIds) {
       const accountEmail = await resolveOwnedAccountEmail(
-        args.accountEmail,
+        resolveBulkGoogleEventAccountEmail(args.ids!, args.accountEmail),
         ownerEmail,
       );
       // Two spellings of one id ("google-a" and "a") would otherwise enqueue two
       // writes for the same event: one succeeds, the other 404s, and the report
       // claims a failure that never happened.
       const requested = Array.from(
-        new Set(args.ids!.map(normalizeWritableGoogleEventId)),
+        new Map(
+          args.ids!.map((id) => [normalizeWritableGoogleEventId(id), id]),
+        ).entries(),
       );
       // Explicit ids get the same booking protection as a filtered selection:
       // naming the event directly does not make leaving its booking confirmed
       // any less of a silent inconsistency.
-      const booked = await findBookedGoogleEvents(requested);
-      for (const googleEventId of requested) {
+      const booked = await findBookedGoogleEvents(requested.map(([id]) => id));
+      for (const [googleEventId, displayId] of requested) {
         const display: BulkEventResult = {
-          id: `google-${googleEventId}`,
+          id: googleEventResultId(displayId, googleEventId, accountEmail),
           accountEmail,
           outcome: "matched",
         };
@@ -290,12 +294,7 @@ export default defineAction({
 
       for (const event of matched) {
         const display: BulkEventResult = {
-          id:
-            event.overlayEmail || event.calendarReadOnly
-              ? event.id
-              : event.googleEventId
-                ? `google-${event.googleEventId}`
-                : event.id,
+          id: event.id,
           title: event.title,
           start: event.start,
           weekday: eventWeekday(event.start, range.timezone),

package/corpus/templates/calendar/actions/event-action-helpers.ts

@@ -12,6 +12,10 @@ import {
 } from "../server/lib/find-time.js";
 import * as googleCalendar from "../server/lib/google-calendar.js";
 import type { CalendarEvent } from "../shared/api.js";
+import {
+  createGoogleAccountEventId,
+  parseGoogleAccountEventId,
+} from "../shared/google-calendar-sources.js";
 
 export const cliBoolean = z
   .union([z.boolean(), z.enum(["true", "false"])])
@@ -190,9 +194,58 @@ export function requireActionUserEmail(): string {
 }
 
 export function normalizeGoogleEventId(id: string): string {
+  const accountEvent = parseGoogleAccountEventId(id);
+  if (accountEvent) return accountEvent.googleEventId;
   return id.startsWith("google-") ? id.slice("google-".length) : id;
 }
 
+export function googleEventResultId(
+  inputId: string,
+  googleEventId: string,
+  accountEmail: string,
+): string {
+  return parseGoogleAccountEventId(inputId)
+    ? createGoogleAccountEventId({ accountEmail, googleEventId })
+    : `google-${googleEventId}`;
+}
+
+export function resolveGoogleEventAccountEmail(
+  id: string,
+  accountEmail: string | undefined,
+): string | undefined {
+  const accountEvent = parseGoogleAccountEventId(id);
+  if (!accountEvent) return accountEmail;
+  if (
+    accountEmail &&
+    accountEmail.trim().toLowerCase() !== accountEvent.accountEmail
+  ) {
+    throw new Error("Google event account does not match the selected account");
+  }
+  return accountEvent.accountEmail;
+}
+
+export function resolveBulkGoogleEventAccountEmail(
+  ids: string[],
+  accountEmail: string | undefined,
+): string | undefined {
+  const scopedCount = ids.filter((id) => parseGoogleAccountEventId(id)).length;
+  if (scopedCount > 0 && scopedCount !== ids.length) {
+    throw new Error(
+      "Bulk event ids cannot mix account-scoped and legacy Google ids",
+    );
+  }
+  const accounts = new Set(
+    ids
+      .map((id) => resolveGoogleEventAccountEmail(id, accountEmail))
+      .filter((email): email is string => !!email)
+      .map((email) => email.trim().toLowerCase()),
+  );
+  if (accounts.size > 1) {
+    throw new Error("Bulk event ids must belong to one Google account");
+  }
+  return accounts.values().next().value ?? accountEmail;
+}
+
 export function normalizeWritableGoogleEventId(id: string): string {
   if (id.startsWith("overlay-") && id.slice("overlay-".length).includes("@")) {
     throw new Error("Overlay Google calendar events are read-only");

package/corpus/templates/calendar/actions/get-event.ts

@@ -5,7 +5,11 @@ import { z } from "zod";
 import { calendarGetEvent } from "../server/lib/google-api.js";
 import * as googleCalendar from "../server/lib/google-calendar.js";
 import type { CalendarEvent } from "../shared/api.js";
-import { parseGoogleCalendarSourceKey } from "../shared/google-calendar-sources.js";
+import {
+  createGoogleAccountEventId,
+  parseGoogleAccountEventId,
+  parseGoogleCalendarSourceKey,
+} from "../shared/google-calendar-sources.js";
 import { getGoogleEventColorHex } from "../shared/google-event-colors.js";
 
 export default defineAction({
@@ -61,26 +65,37 @@ export default defineAction({
   run: async (args) => {
     const email = getRequestUserEmail();
     if (!email) throw new Error("no authenticated user");
+    const accountEvent = parseGoogleAccountEventId(args.id);
 
     if (args.calendarSourceKey) {
       const source = parseGoogleCalendarSourceKey(args.calendarSourceKey);
       if (!source) throw new Error("Invalid Google Calendar source key");
+      if (accountEvent && accountEvent.accountEmail !== source.accountEmail) {
+        throw new Error(
+          "Google event account does not match the selected source",
+        );
+      }
       const namespacedPrefix = `google-${args.calendarSourceKey}-`;
-      const rawId = args.id.startsWith(namespacedPrefix)
-        ? args.id.slice(namespacedPrefix.length)
-        : args.id.startsWith("google-")
-          ? args.id.slice("google-".length)
-          : args.id;
-      return googleCalendar.getEvent(
+      const rawId = accountEvent
+        ? accountEvent.googleEventId
+        : args.id.startsWith(namespacedPrefix)
+          ? args.id.slice(namespacedPrefix.length)
+          : args.id.startsWith("google-")
+            ? args.id.slice("google-".length)
+            : args.id;
+      const event = await googleCalendar.getEvent(
         rawId,
         { ownerEmail: email, accountEmail: source.accountEmail },
         { calendarSourceKey: args.calendarSourceKey },
       );
+      return accountEvent ? { ...event, id: args.id } : event;
     }
 
-    const rawId = args.id.startsWith("google-")
-      ? args.id.slice("google-".length)
-      : args.id;
+    const rawId = accountEvent
+      ? accountEvent.googleEventId
+      : args.id.startsWith("google-")
+        ? args.id.slice("google-".length)
+        : args.id;
     const calendarId = args.calendarId ?? "primary";
     if (calendarId !== "primary") {
       throw new Error(
@@ -88,20 +103,49 @@ export default defineAction({
       );
     }
 
-    const clients = await googleCalendar.getClients(email);
+    const { clients, errors } = accountEvent
+      ? await googleCalendar.getClientsWithErrors(email)
+      : { clients: await googleCalendar.getClients(email), errors: [] };
+    const accountError = accountEvent
+      ? errors.find(
+          ({ email: accountEmail }) =>
+            accountEmail.trim().toLowerCase() === accountEvent.accountEmail,
+        )
+      : undefined;
+    if (accountError) {
+      throw new Error(
+        `Google Calendar connection for ${accountEvent!.accountEmail} failed: ${accountError.error}`,
+      );
+    }
     if (clients.length === 0) {
       return {
         error: "Google Calendar not connected. Connect via Settings first.",
       };
     }
 
-    for (const { email: acctEmail, accessToken } of clients) {
+    const selectedClients = accountEvent
+      ? clients.filter(
+          ({ email: accountEmail }) =>
+            accountEmail.trim().toLowerCase() === accountEvent.accountEmail,
+        )
+      : clients;
+    if (accountEvent && selectedClients.length === 0) {
+      throw new Error(
+        `Google Calendar account is not connected: ${accountEvent.accountEmail}`,
+      );
+    }
+    for (const { email: acctEmail, accessToken } of selectedClients) {
       try {
         const evt = await calendarGetEvent(accessToken, calendarId, rawId);
         const selfAttendee = evt.attendees?.find((a: any) => a.self === true);
 
         const calEvent: CalendarEvent = {
-          id: `google-${evt.id}`,
+          id: accountEvent
+            ? createGoogleAccountEventId({
+                accountEmail: acctEmail,
+                googleEventId: evt.id,
+              })
+            : `google-${evt.id}`,
           title: evt.summary || "Untitled",
           titleIsGenerated: !evt.summary,
           description: evt.description || "",
@@ -185,7 +229,8 @@ export default defineAction({
         };
 
         return calEvent;
-      } catch {
+      } catch (error) {
+        if (accountEvent) throw error;
         // Try next account
         continue;
       }

package/corpus/templates/calendar/actions/rsvp-event.ts

@@ -3,8 +3,10 @@ import { z } from "zod";
 
 import * as googleCalendar from "../server/lib/google-calendar.js";
 import {
+  googleEventResultId,
   normalizeWritableGoogleEventId,
   requireActionUserEmail,
+  resolveGoogleEventAccountEmail,
   resolveOwnedAccountEmail,
 } from "./event-action-helpers.js";
 
@@ -49,11 +51,11 @@ export default defineAction({
       );
     }
 
-    const googleEventId = normalizeWritableGoogleEventId(args.id);
     const accountEmail = await resolveOwnedAccountEmail(
-      args.accountEmail,
+      resolveGoogleEventAccountEmail(args.id, args.accountEmail),
       ownerEmail,
     );
+    const googleEventId = normalizeWritableGoogleEventId(args.id);
 
     await googleCalendar.rsvpEvent(
       googleEventId,
@@ -66,7 +68,7 @@ export default defineAction({
 
     return {
       success: true,
-      id: `google-${googleEventId}`,
+      id: googleEventResultId(args.id, googleEventId, accountEmail),
       accountEmail,
       status: args.status,
       note: args.note?.trim() ?? args.note,

package/corpus/templates/calendar/actions/update-event.ts

@@ -20,12 +20,14 @@ import {
   cliBoolean,
   googleColorIdInput,
   normalizeAttendees,
+  googleEventResultId,
   normalizeWritableGoogleEventId,
   normalizeRecurrence,
   reminderMethodInput,
   reminderMinutesInput,
   remindersInput,
   requireActionUserEmail,
+  resolveGoogleEventAccountEmail,
   resolveOwnedAccountEmail,
   validateEventTimeOrder,
   validateStatusEventTiming,
@@ -256,11 +258,11 @@ export default defineAction({
       );
     }
 
-    const googleEventId = normalizeWritableGoogleEventId(args.id);
     const accountEmail = await resolveOwnedAccountEmail(
-      args.accountEmail,
+      resolveGoogleEventAccountEmail(args.id, args.accountEmail),
       ownerEmail,
     );
+    const googleEventId = normalizeWritableGoogleEventId(args.id);
     const targetAccountEmail =
       args.targetAccountEmail !== undefined
         ? await resolveOwnedAccountEmail(args.targetAccountEmail, ownerEmail)
@@ -445,8 +447,8 @@ export default defineAction({
       );
       return {
         success: true,
-        id: `google-${result.id}`,
-        replacedId: `google-${googleEventId}`,
+        id: googleEventResultId(args.id, result.id, targetAccountEmail!),
+        replacedId: googleEventResultId(args.id, googleEventId, accountEmail),
         accountEmail: targetAccountEmail,
         updated: ["accountEmail"],
         htmlLink: result.htmlLink,
@@ -585,7 +587,7 @@ export default defineAction({
     if (updatedKeys.length === 0 && zoomAlreadyPresent) {
       return {
         success: true,
-        id: `google-${googleEventId}`,
+        id: googleEventResultId(args.id, googleEventId, accountEmail),
         accountEmail,
         updated: [],
         meetingLink: zoomMeetingLink,
@@ -746,9 +748,15 @@ export default defineAction({
 
     return {
       success: true,
-      id: `google-${returnedGoogleEventId}`,
+      id: googleEventResultId(args.id, returnedGoogleEventId, accountEmail),
       ...(returnedGoogleEventId !== googleEventId
-        ? { replacedId: `google-${googleEventId}` }
+        ? {
+            replacedId: googleEventResultId(
+              args.id,
+              googleEventId,
+              accountEmail,
+            ),
+          }
         : {}),
       accountEmail,
       updated: updatedKeys,

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

@@ -13,11 +13,13 @@ import {
   BULK_EVENT_CONCURRENCY,
   MAX_MATCHED_EVENTS,
   cliBoolean,
+  googleEventResultId,
   isBookedOnAccount,
   mapWithConcurrency,
   normalizeWritableGoogleEventId,
   requireActionUserEmail,
   requireExplicitBound,
+  resolveBulkGoogleEventAccountEmail,
   validateEventTimeOrder,
   resolveOwnedAccountEmail,
   startsWithinRange,
@@ -188,22 +190,24 @@ export default defineAction({
 
     if (hasIds) {
       const accountEmail = await resolveOwnedAccountEmail(
-        args.accountEmail,
+        resolveBulkGoogleEventAccountEmail(args.ids!, args.accountEmail),
         ownerEmail,
       );
       const requested = Array.from(
-        new Set(args.ids!.map(normalizeWritableGoogleEventId)),
+        new Map(
+          args.ids!.map((id) => [normalizeWritableGoogleEventId(id), id]),
+        ).entries(),
       );
-      for (const id of requested) {
+      for (const [id, displayId] of requested) {
         try {
           const event = await googleCalendar.getEvent(id, {
             ownerEmail,
             accountEmail,
           });
-          events.push({ event, accountEmail });
+          events.push({ event: { ...event, id: displayId }, accountEmail });
         } catch (error) {
           skipped.push({
-            id: `google-${id}`,
+            id: googleEventResultId(displayId, id, accountEmail),
             accountEmail,
             outcome: "failed",
             reason: isGoogleNotFoundError(error)
@@ -243,7 +247,13 @@ export default defineAction({
       );
       for (const event of matched) {
         const result: BulkEventResult = {
-          id: event.googleEventId ? `google-${event.googleEventId}` : event.id,
+          id: event.googleEventId
+            ? googleEventResultId(
+                event.id,
+                event.googleEventId,
+                event.accountEmail ?? ownerEmail,
+              )
+            : event.id,
           title: event.title,
           start: event.start,
           end: event.end,
@@ -291,7 +301,7 @@ export default defineAction({
       }
       if (isBookedOnAccount(booked, event.googleEventId, accountEmail)) {
         skipped.push({
-          id: `google-${event.googleEventId}`,
+          id: googleEventResultId(event.id, event.googleEventId, accountEmail),
           title: event.title,
           start: event.start,
           end: event.end,
@@ -303,7 +313,7 @@ export default defineAction({
       }
       if (args.shiftMinutes !== undefined && event.allDay) {
         skipped.push({
-          id: `google-${event.googleEventId}`,
+          id: googleEventResultId(event.id, event.googleEventId, accountEmail),
           title: event.title,
           start: event.start,
           end: event.end,
@@ -321,7 +331,7 @@ export default defineAction({
       const range = effectiveRange(event, args);
       assertEffectiveRangeOrdered(event, range);
       return {
-        id: `google-${event.googleEventId}`,
+        id: googleEventResultId(event.id, event.googleEventId!, accountEmail),
         title: event.title,
         start: range.start,
         end: range.end,
@@ -360,7 +370,11 @@ export default defineAction({
             },
           );
           return {
-            id: `google-${event.googleEventId}`,
+            id: googleEventResultId(
+              event.id,
+              event.googleEventId!,
+              accountEmail,
+            ),
             title: event.title,
             start,
             end,
@@ -369,7 +383,11 @@ export default defineAction({
           };
         } catch (error) {
           return {
-            id: `google-${event.googleEventId}`,
+            id: googleEventResultId(
+              event.id,
+              event.googleEventId!,
+              accountEmail,
+            ),
             title: event.title,
             start,
             end,

package/corpus/templates/calendar/changelog/2026-09-21-events-stay-editable-when-their-calendar-is-connected-throug.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-09-21
+---
+
+Events stay editable when their calendar is connected through multiple Google accounts

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

@@ -22,6 +22,7 @@ import type {
   UpdateEventScope,
 } from "../../shared/api.js";
 import {
+  createGoogleAccountEventId,
   createGoogleCalendarCanonicalKey,
   createGoogleCalendarSourceKey,
 } from "../../shared/google-calendar-sources.js";
@@ -1087,6 +1088,26 @@ function compareCalendarSourcePaths(
   return a.accountEmail.localeCompare(b.accountEmail);
 }
 
+function compareCalendarEventSources(
+  a: CalendarEvent,
+  b: CalendarEvent,
+): number {
+  const writable =
+    Number(b.calendarReadOnly === false) - Number(a.calendarReadOnly === false);
+  if (writable !== 0) return writable;
+
+  const primary =
+    Number(b.calendarPrimary === true) - Number(a.calendarPrimary === true);
+  if (primary !== 0) return primary;
+
+  const access =
+    (CALENDAR_ACCESS_RANK[b.calendarAccessRole ?? "freeBusyReader"] ?? -1) -
+    (CALENDAR_ACCESS_RANK[a.calendarAccessRole ?? "freeBusyReader"] ?? -1);
+  if (access !== 0) return access;
+
+  return (a.accountEmail ?? "").localeCompare(b.accountEmail ?? "");
+}
+
 /**
  * Resolve a client-supplied canonical source identity against the user's live
  * CalendarList. Provider paths stay server-selected, so a stale or forged
@@ -1097,9 +1118,17 @@ export async function resolveGoogleCalendarSource(
   sourceKey: string,
 ): Promise<GoogleCalendarSource> {
   const discovered = await listGoogleCalendars(ownerEmail);
-  const source = discovered.calendars.find(
-    (candidate) => candidate.sourceKey === sourceKey,
-  );
+  const source = discovered.calendars
+    .flatMap((candidate) =>
+      (candidate.sourcePaths ?? [candidate]).map((path) => ({
+        ...candidate,
+        ...path,
+        readOnly:
+          path.primary !== true ||
+          (path.accessRole !== "owner" && path.accessRole !== "writer"),
+      })),
+    )
+    .find((candidate) => candidate.sourceKey === sourceKey);
   if (!source) {
     throw new Error(
       "Google Calendar source is not connected or no longer available",
@@ -1331,6 +1360,8 @@ export async function listEvents(
   // "calendar is empty" and the user sees no error.
   const errors: Array<{ email: string; error: string }> = [...refreshErrors];
   if (clients.length === 0) return { events: [], errors };
+  const hasMultipleOwnedAccounts =
+    clients.length > 1 || (await getOwnedAccountEmails(forEmail)).length > 1;
 
   const requestedSourceKeys = Array.from(
     new Set((options.calendarSourceKeys ?? []).filter(Boolean)),
@@ -1339,9 +1370,27 @@ export async function listEvents(
   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 discoveredByKey = new Map<
+      string,
+      {
+        source: GoogleCalendarSource;
+        paths: Array<
+          Pick<
+            GoogleCalendarSource,
+            "sourceKey" | "accountEmail" | "accessRole" | "primary"
+          >
+        >;
+      }
+    >();
+    for (const source of discovered.calendars) {
+      const paths = source.sourcePaths ?? [source];
+      discoveredByKey.set(source.sourceKey, { source, paths });
+      for (const path of paths) {
+        if (path.sourceKey !== source.sourceKey) {
+          discoveredByKey.set(path.sourceKey, { source, paths: [path] });
+        }
+      }
+    }
     const invalid = requestedSourceKeys.filter(
       (sourceKey) => !discoveredByKey.has(sourceKey),
     );
@@ -1351,21 +1400,14 @@ export async function listEvents(
       );
     }
     for (const sourceKey of requestedSourceKeys) {
-      const source = discoveredByKey.get(sourceKey)!;
-      const paths = source.sourcePaths ?? [
-        {
-          sourceKey: source.sourceKey,
-          accountEmail: source.accountEmail,
-          accessRole: source.accessRole,
-          primary: source.primary,
-        },
-      ];
+      const { source, paths } = discoveredByKey.get(sourceKey)!;
       for (const path of paths) {
         const accountKey = path.accountEmail.trim().toLowerCase();
         selectedSourcesByAccount.set(accountKey, [
           ...(selectedSourcesByAccount.get(accountKey) ?? []),
           {
             ...source,
+            sourceKey: path.sourceKey,
             accountEmail: path.accountEmail,
             accessRole: path.accessRole,
             primary: path.primary,
@@ -1457,7 +1499,12 @@ export async function listEvents(
             id:
               calendarSource && !calendarSource.primary
                 ? `google-${calendarSource.sourceKey}-${event.id}`
-                : `google-${event.id}`,
+                : hasMultipleOwnedAccounts
+                  ? createGoogleAccountEventId({
+                      accountEmail: email,
+                      googleEventId: event.id,
+                    })
+                  : `google-${event.id}`,
             title: event.summary || "Untitled",
             titleIsGenerated: !event.summary,
             description: event.description || "",
@@ -1538,8 +1585,13 @@ export async function listEvents(
     const key =
       event.canonicalKey && event.googleEventId
         ? `${event.canonicalKey}:${event.googleEventId}`
-        : event.id;
-    if (!dedupedEvents.has(key)) dedupedEvents.set(key, event);
+        : event.googleEventId && event.accountEmail
+          ? `google-account:${event.accountEmail.toLowerCase()}:${event.googleEventId}`
+          : event.id;
+    const existing = dedupedEvents.get(key);
+    if (!existing || compareCalendarEventSources(event, existing) < 0) {
+      dedupedEvents.set(key, event);
+    }
   }
   return { events: Array.from(dedupedEvents.values()), errors };
 }