@sentry/junior-google 0.238.1 → 0.240.0

package/dist/index.js

@@ -441,6 +441,11 @@ var GOOGLE_OPERATIONS = {
     method: "POST",
     path: /^\/calendar\/v3\/calendars\/primary\/events$/
   },
+  "google.calendar.event.delete": {
+    access: "write",
+    method: "DELETE",
+    path: /^\/calendar\/v3\/calendars\/primary\/events\/[A-Za-z0-9_]+$/
+  },
   "google.calendar.event.get": {
     access: "read",
     method: "GET",
@@ -726,11 +731,9 @@ function createGoogleSetupPage() {
   };
 }
 
-// src/tools/create-event.ts
-import { createHash as createHash2, randomUUID } from "crypto";
+// src/tools/cancel-event.ts
 import {
   definePluginTool,
-  PluginToolInputError as PluginToolInputError2,
   pluginToolOutputSchema
 } from "@sentry/junior-plugin-api";
 import { z as z3 } from "zod";
@@ -741,8 +744,8 @@ import {
 } from "@sentry/junior-plugin-api";
 import { z as z2 } from "zod";
 var emailListSchema = (max) => z2.array(z2.string().trim().toLowerCase().pipe(z2.email())).max(max).describe("Attendee email addresses.");
-var timeZoneSchema = z2.string().min(1).refine(isTimeZone, "timeZone must be an IANA time zone").describe(
-  "IANA time zone used to read and show times, such as America/Los_Angeles."
+var timeZoneSchema = z2.string().min(1).refine(isTimeZone, "timeZone must be an IANA time zone").optional().describe(
+  "IANA time zone used to read and show times, such as America/Los_Angeles. Omit to use the requester's time zone."
 );
 function isTimeZone(value) {
   try {
@@ -808,79 +811,285 @@ function formatInterval(startMs, endMs, timeZone) {
     timeZone,
     weekday: "short"
   }).format(startMs);
-  const time = new Intl.DateTimeFormat("en-US", {
+  const time = (timeZoneName) => new Intl.DateTimeFormat("en-US", {
     hour: "2-digit",
     hourCycle: "h23",
     minute: "2-digit",
     timeZone,
-    timeZoneName: "short"
+    timeZoneName
   });
-  return `${day}, ${time.format(startMs)} \u2013 ${time.format(endMs)}`;
+  return `${day}, ${time().format(startMs)} \u2013 ${time("short").format(endMs)}`;
 }
 var MAX_EVENT_MS = 8 * 60 * 60 * 1e3;
+var googleAttendeeSchema = z2.object({
+  displayName: z2.string().optional(),
+  email: z2.string(),
+  optional: z2.boolean().optional(),
+  resource: z2.boolean().optional(),
+  responseStatus: z2.string().optional()
+}).loose();
+var attendeeOutputSchema = z2.object({
+  email: z2.string(),
+  optional: z2.boolean().optional(),
+  response: z2.enum(["accepted", "declined", "tentative", "needsAction"]).optional()
+});
+var RESPONSES = /* @__PURE__ */ new Set(["accepted", "declined", "tentative", "needsAction"]);
+function attendeeResults(attendees) {
+  return (attendees ?? []).filter((attendee) => attendee.resource !== true).map((attendee) => ({
+    email: attendee.email.toLowerCase(),
+    ...attendee.optional ? { optional: true } : void 0,
+    ...attendee.responseStatus && RESPONSES.has(attendee.responseStatus) ? {
+      response: attendee.responseStatus
+    } : void 0
+  }));
+}
 var ownEventSchema = z2.object({
-  attendees: z2.array(
-    z2.object({ email: z2.string(), responseStatus: z2.string().optional() }).loose()
-  ).optional(),
+  attendees: z2.array(googleAttendeeSchema).optional(),
+  description: z2.string().optional(),
   end: z2.object({ dateTime: z2.string() }),
   hangoutLink: z2.string().optional(),
   htmlLink: z2.string().optional(),
   id: z2.string(),
+  location: z2.string().optional(),
   organizer: z2.object({ self: z2.boolean().optional() }).optional(),
+  recurrence: z2.array(z2.string()).optional(),
+  recurringEventId: z2.string().optional(),
   start: z2.object({ dateTime: z2.string() }),
-  summary: z2.string().optional()
+  summary: z2.string().optional(),
+  updated: z2.string().optional()
 });
 function ownEventResult(event, timeZone) {
+  const startMs = Date.parse(event.start.dateTime);
+  const when = formatInterval(
+    startMs,
+    Date.parse(event.end.dateTime),
+    timeZone
+  );
+  const annotation = {
+    kind: "object",
+    key: event.id,
+    label: new Intl.DateTimeFormat("en-US", {
+      day: "numeric",
+      month: "short",
+      timeZone
+    }).format(startMs),
+    objectType: "calendar_event",
+    // People can edit the event in Calendar. Shorten long values so a
+    // completed change never fails on the annotation schema.
+    title: (event.summary?.trim() || "Untitled event").slice(0, 512),
+    url: event.htmlLink ?? null,
+    description: event.description?.trim().slice(0, 4e3) || void 0,
+    sourceUpdatedAt: event.updated,
+    facts: {
+      type: "calendar_event",
+      when,
+      attendees: (event.attendees ?? []).filter((attendee) => attendee.resource !== true).slice(0, 5).map(
+        (attendee) => (attendee.displayName?.trim() || attendee.email).slice(0, 160)
+      )
+    }
+  };
   return {
-    attendees: (event.attendees ?? []).map((attendee) => attendee.email),
+    objectAnnotations: [annotation],
+    attendees: attendeeResults(event.attendees),
     end: event.end.dateTime,
     eventId: event.id,
-    label: formatInterval(
-      Date.parse(event.start.dateTime),
-      Date.parse(event.end.dateTime),
-      timeZone
-    ),
+    label: when,
     start: event.start.dateTime,
     ...event.summary ? { title: event.summary } : void 0,
+    ...event.location ? { location: event.location } : void 0,
+    ...event.recurrence ? { repeats: true } : void 0,
+    ...event.recurringEventId ? { seriesEventId: event.recurringEventId } : void 0,
     ...event.htmlLink ? { url: event.htmlLink } : void 0,
     ...event.hangoutLink ? { videoCallUrl: event.hangoutLink } : void 0
   };
 }
 var ownEventOutputFields = {
-  attendees: z2.array(z2.string()),
+  attendees: z2.array(attendeeOutputSchema),
   end: z2.string(),
   eventId: z2.string(),
   label: z2.string(),
+  location: z2.string().optional(),
+  repeats: z2.boolean().optional().describe("True when this event id is a whole repeating series."),
+  seriesEventId: z2.string().optional().describe(
+    "Set when this is one occurrence of a repeating event. Use it as eventId to change or cancel the whole series."
+  ),
   start: z2.string(),
   title: z2.string().optional(),
   url: z2.string().optional(),
   videoCallUrl: z2.string().optional()
 };
+var ownEventIdSchema = z2.string().trim().min(5).max(2048).describe(
+  "Event id from a Calendar tool, or a Google Calendar event link. An occurrence of a repeating event has its own id; its seriesEventId is the whole series."
+);
+var EVENT_ID_PATTERN = /^[A-Za-z0-9_]{5,1024}$/;
+function parseEventId(value) {
+  let eventId = value;
+  if (/^https?:\/\//.test(value)) {
+    const eid = URL.parse(value)?.searchParams.get("eid");
+    eventId = eid ? Buffer.from(eid, "base64").toString("utf8").split(" ")[0] ?? "" : "";
+  }
+  if (!EVENT_ID_PATTERN.test(eventId)) {
+    throw new PluginToolInputError(
+      "Use an event id from a Calendar tool or a Google Calendar event link."
+    );
+  }
+  return eventId;
+}
+var cancelledEventSchema = z2.object({ status: z2.literal("cancelled") });
+async function readOwnEventForRequester(ctx, eventIdOrLink, action) {
+  const eventId = parseEventId(eventIdOrLink);
+  const requester = await requesterEmail(ctx);
+  if (!requester) {
+    throw new PluginToolInputError(
+      `Junior does not know the requester's email, so it cannot check that they may ${action} this event.`
+    );
+  }
+  const path = `/calendar/v3/calendars/primary/events/${eventId}`;
+  const response = await googleApiRequest(ctx, {
+    operation: "google.calendar.event.get",
+    path
+  });
+  if (response.status === 410 || response.status === 200 && cancelledEventSchema.safeParse(response.body).success) {
+    return { eventId, path, status: "cancelled" };
+  }
+  if (response.status === 404) {
+    throw new PluginToolInputError(
+      `Junior's calendar has no event ${eventId}. Junior can only ${action} events it organizes; ask the organizer instead.`
+    );
+  }
+  if (response.status !== 200) {
+    throw googleApiError("google.calendar.event.get", response);
+  }
+  const event = ownEventSchema.parse(response.body);
+  if (event.organizer?.self !== true) {
+    throw new PluginToolInputError(
+      `Junior does not organize this event, so it cannot ${action} it. Ask the organizer instead.`
+    );
+  }
+  if (!(event.attendees ?? []).some(
+    (attendee) => attendee.email.toLowerCase() === requester
+  )) {
+    throw new PluginToolInputError(
+      `Only people invited to this event can ask Junior to ${action} it.`
+    );
+  }
+  return { event, eventId, path, status: "active" };
+}
 
-// src/tools/create-event.ts
+// src/tools/cancel-event.ts
 var inputSchema = z3.object({
-  title: z3.string().trim().min(1).max(200),
-  description: z3.string().max(4e3).optional().describe(
-    "Event description. Do not include private details the attendees should not see."
+  eventId: ownEventIdSchema,
+  timeZone: timeZoneSchema
+}).strict();
+var outputSchema = pluginToolOutputSchema.extend({
+  target: z3.literal("cancelCalendarEvent"),
+  cancelled: z3.boolean().describe(
+    "False when the event was already cancelled before this call. Event details are then missing."
+  ),
+  ...ownEventOutputFields
+}).partial({ attendees: true, end: true, label: true, start: true });
+function createCancelCalendarEventTool(ctx) {
+  return definePluginTool({
+    annotations: {
+      destructiveHint: true,
+      idempotentHint: true,
+      openWorldHint: true,
+      readOnlyHint: false
+    },
+    describeProposal(input) {
+      return `Cancel Google Calendar event ${input.eventId} organized by Junior. Google emails every attendee a cancellation.`;
+    },
+    description: "Cancel a Google Calendar event organized by Junior's own Google account. Google removes it from every attendee's calendar and emails them a cancellation. Only people invited to the event can ask to cancel it. Junior cannot cancel events other people organize. For a repeating event, an occurrence id cancels only that occurrence; its seriesEventId cancels every occurrence. Confirm which event, and for a repeating event whether one occurrence or the series, unless the requester already made it clear.",
+    inputSchema,
+    outputSchema,
+    async execute(input) {
+      const timeZone = input.timeZone ?? await ctx.users.resolveTimezone();
+      const read = await readOwnEventForRequester(ctx, input.eventId, "cancel");
+      if (read.status === "cancelled") {
+        return {
+          target: "cancelCalendarEvent",
+          cancelled: false,
+          eventId: read.eventId
+        };
+      }
+      const { event, path } = read;
+      const result = {
+        target: "cancelCalendarEvent",
+        ...ownEventResult(event, timeZone)
+      };
+      const response = await googleApiRequest(ctx, {
+        operation: "google.calendar.event.delete",
+        path,
+        query: { sendUpdates: "all" }
+      });
+      if (response.status !== 204 && response.status !== 410) {
+        throw googleApiError("google.calendar.event.delete", response);
+      }
+      return {
+        ...result,
+        // Keep the card in the Conversation, and show that the event is gone.
+        objectAnnotations: result.objectAnnotations.map((annotation) => ({
+          ...annotation,
+          status: "cancelled"
+        })),
+        cancelled: response.status === 204
+      };
+    }
+  });
+}
+
+// src/tools/create-event.ts
+import { createHash as createHash2, randomUUID } from "crypto";
+import {
+  definePluginTool as definePluginTool2,
+  PluginToolInputError as PluginToolInputError2,
+  pluginToolOutputSchema as pluginToolOutputSchema2
+} from "@sentry/junior-plugin-api";
+import { z as z4 } from "zod";
+var repeatSchema = z4.object({
+  frequency: z4.enum(["weekdays", "weekly", "monthly"]).describe(
+    "`weekdays` repeats Monday to Friday. `weekly` repeats on the start's weekday. `monthly` repeats on the start's day of the month."
+  ),
+  interval: z4.number().int().min(1).max(12).default(1).describe(
+    "Repeat every N weeks or months. 2 with `weekly` means every other week. Ignored for `weekdays`."
   ),
-  start: z3.iso.datetime({ offset: true }).describe("Event start, RFC 3339 with offset."),
-  end: z3.iso.datetime({ offset: true }).describe("Event end, RFC 3339 with offset."),
+  count: z4.number().int().min(2).max(200).optional().describe("Number of occurrences. Omit when the series has no end.")
+}).strict();
+function recurrenceRule(repeat) {
+  const parts = repeat.frequency === "weekdays" ? ["FREQ=WEEKLY", "BYDAY=MO,TU,WE,TH,FR"] : [
+    `FREQ=${repeat.frequency === "weekly" ? "WEEKLY" : "MONTHLY"}`,
+    ...repeat.interval > 1 ? [`INTERVAL=${repeat.interval}`] : []
+  ];
+  if (repeat.count) parts.push(`COUNT=${repeat.count}`);
+  return `RRULE:${parts.join(";")}`;
+}
+var inputSchema2 = z4.object({
+  title: z4.string().trim().min(1).max(200).describe(
+    'Specific title that says who and what, such as "Alice / Bob: Q4 hiring plan". Avoid generic titles such as "Meeting" or "Sync".'
+  ),
+  description: z4.string().max(4e3).optional().describe(
+    "Purpose, agenda, and links attendees need to prepare. Do not include private details the attendees should not see."
+  ),
+  location: z4.string().trim().max(500).optional().describe("Room name or address for an in-person meeting."),
+  start: z4.iso.datetime({ offset: true }).describe("Event start, RFC 3339 with offset."),
+  end: z4.iso.datetime({ offset: true }).describe("Event end, RFC 3339 with offset."),
   timeZone: timeZoneSchema,
   attendees: emailListSchema(50).describe(
-    "Email addresses to invite. Junior adds the requester automatically when it knows their email."
+    "Email addresses of required attendees. Junior adds the requester automatically when it knows their email."
   ),
-  addVideoCall: z3.boolean().default(true).describe("Add a Google Meet link.")
+  optionalAttendees: emailListSchema(50).default([]).describe("Email addresses to invite as optional attendees."),
+  repeat: repeatSchema.optional().describe("Make a repeating series, such as a weekly 1:1.")
 }).strict();
-var outputSchema = pluginToolOutputSchema.extend({
-  target: z3.literal("createCalendarEvent"),
-  created: z3.boolean(),
+var outputSchema2 = pluginToolOutputSchema2.extend({
+  target: z4.literal("createCalendarEvent"),
+  created: z4.boolean(),
   ...ownEventOutputFields
 });
 function calendarEventId(toolCallId) {
   return createHash2("sha256").update(`junior-google:${toolCallId ?? randomUUID()}`).digest("hex").slice(0, 40);
 }
 function createCreateCalendarEventTool(ctx) {
-  return definePluginTool({
+  return definePluginTool2({
     annotations: {
       destructiveHint: false,
       idempotentHint: true,
@@ -888,12 +1097,15 @@ function createCreateCalendarEventTool(ctx) {
       readOnlyHint: false
     },
     describeProposal(input) {
-      return `Create Google Calendar event "${input.title}" from ${input.start} to ${input.end} and email invites to ${input.attendees.join(", ") || "the requester"}.`;
+      const optional = input.optionalAttendees.length ? ` (optional: ${input.optionalAttendees.join(", ")})` : "";
+      const repeat = input.repeat ? `, repeating ${recurrenceRule(input.repeat)}` : "";
+      return `Create Google Calendar event "${input.title}" from ${input.start} to ${input.end}${repeat} and email invites to ${input.attendees.join(", ") || "the requester"}${optional}.`;
     },
-    description: "Create a Google Calendar event organized by Junior's own Google account and email invites to the attendees. Use after the requester confirms the time. Only people in the company's Google Workspace domains can be invited.",
-    inputSchema,
-    outputSchema,
+    description: "Create a Google Calendar event organized by Junior's own Google account and email invites to the attendees. Every event gets a Google Meet link. Junior can later change or cancel it. Use after the requester confirms the time, or when they already gave an exact time. Check the time with findMeetingTimes first unless the requester says to book it anyway. Only people in the company's Google Workspace domains can be invited.",
+    inputSchema: inputSchema2,
+    outputSchema: outputSchema2,
     async execute(input, options) {
+      const timeZone = input.timeZone ?? await ctx.users.resolveTimezone();
       const startMs = Date.parse(input.start);
       const endMs = Date.parse(input.end);
       if (endMs <= startMs) {
@@ -903,33 +1115,43 @@ function createCreateCalendarEventTool(ctx) {
         throw new PluginToolInputError2("Events can be at most 8 hours long.");
       }
       const attendees = await withRequester(ctx, input.attendees);
-      if (attendees.length === 0) {
+      const required = new Set(attendees);
+      const optionalAttendees = [...new Set(input.optionalAttendees)].filter(
+        (email) => !required.has(email)
+      );
+      if (attendees.length + optionalAttendees.length === 0) {
         throw new PluginToolInputError2("Invite at least one attendee.");
       }
-      requireAllowedEmails(attendees, ctx.allowedDomains);
+      requireAllowedEmails(
+        [...attendees, ...optionalAttendees],
+        ctx.allowedDomains
+      );
       const eventId = calendarEventId(options.toolCallId);
       const response = await googleApiRequest(ctx, {
         body: {
-          attendees: attendees.map((email) => ({ email })),
-          ...input.addVideoCall ? {
-            conferenceData: {
-              createRequest: {
-                conferenceSolutionKey: { type: "hangoutsMeet" },
-                requestId: eventId
-              }
+          attendees: [
+            ...attendees.map((email) => ({ email })),
+            ...optionalAttendees.map((email) => ({ email, optional: true }))
+          ],
+          conferenceData: {
+            createRequest: {
+              conferenceSolutionKey: { type: "hangoutsMeet" },
+              requestId: eventId
             }
-          } : void 0,
+          },
           ...input.description ? { description: input.description } : void 0,
-          end: { dateTime: input.end, timeZone: input.timeZone },
+          end: { dateTime: input.end, timeZone },
           guestsCanModify: false,
           id: eventId,
-          start: { dateTime: input.start, timeZone: input.timeZone },
+          ...input.location ? { location: input.location } : void 0,
+          ...input.repeat ? { recurrence: [recurrenceRule(input.repeat)] } : void 0,
+          start: { dateTime: input.start, timeZone },
           summary: input.title
         },
         operation: "google.calendar.event.create",
         path: "/calendar/v3/calendars/primary/events",
         query: {
-          conferenceDataVersion: input.addVideoCall ? "1" : "0",
+          conferenceDataVersion: "1",
           sendUpdates: "all"
         }
       });
@@ -950,7 +1172,7 @@ function createCreateCalendarEventTool(ctx) {
       return {
         target: "createCalendarEvent",
         created,
-        ...ownEventResult(ownEventSchema.parse(event.body), input.timeZone)
+        ...ownEventResult(ownEventSchema.parse(event.body), timeZone)
       };
     }
   });
@@ -958,48 +1180,73 @@ function createCreateCalendarEventTool(ctx) {
 
 // src/tools/find-meeting-times.ts
 import {
-  definePluginTool as definePluginTool2,
+  definePluginTool as definePluginTool3,
   PluginToolInputError as PluginToolInputError3,
-  pluginToolOutputSchema as pluginToolOutputSchema2
+  pluginToolOutputSchema as pluginToolOutputSchema3
 } from "@sentry/junior-plugin-api";
-import { z as z4 } from "zod";
-var MAX_WINDOW_MS = 14 * 24 * 60 * 60 * 1e3;
-var clockTimeSchema = z4.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/, "Use 24-hour HH:MM");
-var inputSchema2 = z4.object({
+import { z as z5 } from "zod";
+var DAY_MS = 24 * 60 * 60 * 1e3;
+var MAX_WINDOW_MS = 14 * DAY_MS;
+var DEFAULT_WINDOW_MS = 7 * DAY_MS;
+var clockTimeSchema = z5.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/, "Use 24-hour HH:MM");
+var inputSchema3 = z5.object({
   attendees: emailListSchema(20).min(1).describe(
-    "Email addresses of the people who must attend. Junior adds the requester automatically when it knows their email."
+    "Work emails of the people who must attend. Resolve names with userLookup. Junior adds the requester automatically when it knows their email."
   ),
-  durationMinutes: z4.number().int().min(15).max(480),
-  timeMin: z4.iso.datetime({ offset: true }).describe("Start of the search window, RFC 3339 with offset."),
-  timeMax: z4.iso.datetime({ offset: true }).describe(
-    "End of the search window, RFC 3339 with offset. At most 14 days after timeMin."
+  optionalAttendees: emailListSchema(20).default([]).describe(
+    'Work emails of people the requester calls optional or "if free". Their conflicts do not block a slot; slots where they are free come first.'
   ),
-  timeZone: timeZoneSchema,
-  workdayStart: clockTimeSchema.default("09:00").describe("Earliest local start time in timeZone, 24-hour HH:MM."),
-  workdayEnd: clockTimeSchema.default("17:00").describe("Latest local end time in timeZone, 24-hour HH:MM."),
-  maxResults: z4.number().int().min(1).max(20).default(5)
+  durationMinutes: z5.number().int().min(15).max(480).default(30),
+  timeMin: z5.iso.datetime({ offset: true }).optional().describe(
+    "Start of the search window, RFC 3339 with offset. Defaults to now. For an exact requested time, search only that slot."
+  ),
+  timeMax: z5.iso.datetime({ offset: true }).optional().describe(
+    "End of the search window, RFC 3339 with offset. Defaults to 7 days after timeMin. At most 14 days after timeMin."
+  ),
+  timeZone: timeZoneSchema.describe(
+    "IANA time zone for slot labels, such as America/Los_Angeles. Omit to use the requester's time zone. It is also the working-hours zone for anyone whose calendar time zone Junior cannot read."
+  ),
+  workdayStart: clockTimeSchema.default("09:00").describe(
+    "Earliest local start, 24-hour HH:MM, in each attendee's own calendar time zone."
+  ),
+  workdayEnd: clockTimeSchema.default("17:00").describe(
+    "Latest local end, 24-hour HH:MM, in each attendee's own calendar time zone."
+  ),
+  maxResults: z5.number().int().min(1).max(20).default(3)
 }).strict();
-var slotSchema = z4.object({
-  end: z4.string(),
-  label: z4.string(),
-  start: z4.string()
+var slotSchema = z5.object({
+  end: z5.string(),
+  label: z5.string().describe("The slot in the requester's time zone."),
+  otherTimeZoneLabels: z5.array(z5.string()).optional().describe("The slot in the other attendees' time zones."),
+  optionalConflicts: z5.array(z5.string()).optional().describe(
+    "Optional attendees who are busy or outside their working hours at this time."
+  ),
+  start: z5.string()
 });
-var outputSchema2 = pluginToolOutputSchema2.extend({
-  target: z4.literal("findMeetingTimes"),
-  checked: z4.array(z4.string()),
-  slots: z4.array(slotSchema),
-  timeZone: z4.string(),
-  unavailable: z4.array(z4.object({ email: z4.string(), reason: z4.string() }))
+var outputSchema3 = pluginToolOutputSchema3.extend({
+  target: z5.literal("findMeetingTimes"),
+  checked: z5.array(
+    z5.object({
+      email: z5.string(),
+      timeZone: z5.string().optional().describe(
+        "Time zone of the person's calendar. Missing when Junior cannot read it; their hours then use the requester's time zone."
+      )
+    })
+  ),
+  slots: z5.array(slotSchema),
+  timeZone: z5.string(),
+  unavailable: z5.array(z5.object({ email: z5.string(), reason: z5.string() }))
 });
-var freeBusyResponseSchema = z4.object({
-  calendars: z4.record(
-    z4.string(),
-    z4.object({
-      busy: z4.array(z4.object({ end: z4.string(), start: z4.string() })).default([]),
-      errors: z4.array(z4.object({ reason: z4.string() })).optional()
+var freeBusyResponseSchema = z5.object({
+  calendars: z5.record(
+    z5.string(),
+    z5.object({
+      busy: z5.array(z5.object({ end: z5.string(), start: z5.string() })).default([]),
+      errors: z5.array(z5.object({ reason: z5.string() })).optional()
     })
   )
 });
+var calendarTimeZoneSchema = z5.object({ timeZone: z5.string().optional() });
 function localParts(ms, format) {
   const parts = Object.fromEntries(
     format.formatToParts(ms).map((part) => [part.type, part.value])
@@ -1010,58 +1257,151 @@ function localParts(ms, format) {
     weekday: parts.weekday ?? ""
   };
 }
-function clockMinutes(value) {
-  const [hours, minutes] = value.split(":").map(Number);
-  return hours * 60 + minutes;
-}
-function findFreeSlots(input) {
-  const durationMs = input.durationMinutes * 6e4;
-  const stepMs = (input.durationMinutes < 30 ? 15 : 30) * 6e4;
-  const format = new Intl.DateTimeFormat("en-US", {
+function localFormat(timeZone) {
+  return new Intl.DateTimeFormat("en-US", {
     day: "2-digit",
     hour: "2-digit",
     hourCycle: "h23",
     minute: "2-digit",
     month: "2-digit",
-    timeZone: input.timeZone,
+    timeZone,
     weekday: "short",
     year: "numeric"
   });
+}
+function clockMinutes(value) {
+  const [hours, minutes] = value.split(":").map(Number);
+  return hours * 60 + minutes;
+}
+function overlaps(busy, startMs, endMs) {
+  return busy.endMs > startMs && busy.startMs < endMs;
+}
+function farthestOption(options, chosen) {
+  if (chosen.length === 0) return options[0];
+  let best;
+  let bestGap = -1;
+  for (const option of options) {
+    const gap = Math.min(
+      ...chosen.map((slot) => Math.abs(slot.startMs - option.startMs))
+    );
+    if (gap > bestGap) {
+      best = option;
+      bestGap = gap;
+    }
+  }
+  return best;
+}
+function spreadAcrossDays(candidates, max) {
+  const days = /* @__PURE__ */ new Map();
+  for (const candidate of candidates) {
+    days.set(candidate.date, [...days.get(candidate.date) ?? [], candidate]);
+  }
+  const chosen = /* @__PURE__ */ new Map();
+  const result = [];
+  let progress = true;
+  while (result.length < max && progress) {
+    progress = false;
+    for (const [date, options] of days) {
+      if (result.length >= max) break;
+      const picked = chosen.get(date) ?? [];
+      const next = farthestOption(options, picked);
+      if (!next) continue;
+      options.splice(options.indexOf(next), 1);
+      picked.push(next);
+      chosen.set(date, picked);
+      result.push(next);
+      progress = true;
+    }
+  }
+  return result;
+}
+function findFreeSlots(input) {
+  const durationMs = input.durationMinutes * 6e4;
+  const stepMs = (input.durationMinutes < 30 ? 15 : 30) * 6e4;
   const dayStart = clockMinutes(input.workdayStart);
   const dayEnd = clockMinutes(input.workdayEnd);
-  const slots = [];
+  const formats = /* @__PURE__ */ new Map();
+  const partsIn = (ms, timeZone) => {
+    let format = formats.get(timeZone);
+    if (!format) {
+      format = localFormat(timeZone);
+      formats.set(timeZone, format);
+    }
+    return localParts(ms, format);
+  };
+  const available = (attendee, startMs2, endMs) => {
+    const start = partsIn(startMs2, attendee.timeZone);
+    const end = partsIn(endMs, attendee.timeZone);
+    return start.weekday !== "Sat" && start.weekday !== "Sun" && start.date === end.date && start.minutes >= dayStart && end.minutes <= dayEnd && attendee.busy.every((busy) => !overlaps(busy, startMs2, endMs));
+  };
+  const required = input.attendees.filter((attendee) => attendee.required);
+  const optional = input.attendees.filter((attendee) => !attendee.required);
+  const candidates = [];
   let startMs = Math.ceil(input.timeMinMs / stepMs) * stepMs;
-  while (startMs + durationMs <= input.timeMaxMs && slots.length < input.maxResults) {
+  while (startMs + durationMs <= input.timeMaxMs) {
     const endMs = startMs + durationMs;
-    const start = localParts(startMs, format);
-    const end = localParts(endMs, format);
-    const inWorkday = start.weekday !== "Sat" && start.weekday !== "Sun" && start.date === end.date && start.minutes >= dayStart && end.minutes <= dayEnd;
-    const free = input.busy.every(
-      (busy) => busy.endMs <= startMs || busy.startMs >= endMs
-    );
-    if (inWorkday && free) {
-      slots.push({ startMs, endMs });
+    if (required.every((attendee) => available(attendee, startMs, endMs))) {
+      candidates.push({
+        date: partsIn(startMs, input.timeZone).date,
+        endMs,
+        optionalConflicts: optional.filter((attendee) => !available(attendee, startMs, endMs)).map((attendee) => attendee.email),
+        startMs
+      });
       startMs = endMs;
     } else {
       startMs += stepMs;
     }
   }
-  return slots;
+  const picked = spreadAcrossDays(
+    candidates.filter((slot) => slot.optionalConflicts.length === 0),
+    input.maxResults
+  );
+  picked.push(
+    ...spreadAcrossDays(
+      candidates.filter((slot) => slot.optionalConflicts.length > 0),
+      input.maxResults - picked.length
+    )
+  );
+  return picked.sort((a, b) => a.startMs - b.startMs).map(({ endMs, optionalConflicts, startMs: startMs2 }) => ({
+    endMs,
+    optionalConflicts,
+    startMs: startMs2
+  }));
+}
+async function calendarTimeZone(ctx, email) {
+  const response = await googleApiRequest(ctx, {
+    operation: "google.calendar.events.list",
+    path: `/calendar/v3/calendars/${encodeURIComponent(email)}/events`,
+    // No `timeZone` parameter: Google then answers with the calendar's own.
+    query: { fields: "timeZone", maxResults: "1" }
+  });
+  if (response.status === 403 || response.status === 404) {
+    return void 0;
+  }
+  if (response.status !== 200) {
+    throw googleApiError("google.calendar.events.list", response);
+  }
+  const { timeZone } = calendarTimeZoneSchema.parse(response.body);
+  return timeZone && isTimeZone(timeZone) ? timeZone : void 0;
 }
 function createFindMeetingTimesTool(ctx) {
-  return definePluginTool2({
+  return definePluginTool3({
     annotations: {
       destructiveHint: false,
       idempotentHint: true,
       openWorldHint: true,
       readOnlyHint: true
     },
-    description: "Find meeting times when every attendee is free, using Google Calendar free/busy data from Junior's own Google account. Returns open slots only, never event details. Only people in the company's Google Workspace domains can be checked. People listed in `unavailable` were not checked; tell the user instead of treating them as free.",
-    inputSchema: inputSchema2,
-    outputSchema: outputSchema2,
+    description: "Find meeting times when every required attendee is free and inside working hours in their own calendar time zone, using Google Calendar free/busy data from Junior's own Google account. Returns open slots only, never event details. Slots are spread across days and times; offer them as a short list. Only people in the company's Google Workspace domains can be checked. People in `unavailable` were not checked: say so instead of treating them as free. If no slot is free, widen the window or shorten the meeting once, then offer the closest option.",
+    inputSchema: inputSchema3,
+    outputSchema: outputSchema3,
     async execute(input) {
-      const timeMinMs = Math.max(Date.parse(input.timeMin), Date.now());
-      const timeMaxMs = Date.parse(input.timeMax);
+      const timeZone = input.timeZone ?? await ctx.users.resolveTimezone();
+      const timeMinMs = Math.max(
+        input.timeMin ? Date.parse(input.timeMin) : 0,
+        Date.now()
+      );
+      const timeMaxMs = input.timeMax ? Date.parse(input.timeMax) : timeMinMs + DEFAULT_WINDOW_MS;
       if (timeMaxMs <= timeMinMs) {
         throw new PluginToolInputError3(
           "timeMax must be after timeMin and now."
@@ -1076,57 +1416,81 @@ function createFindMeetingTimesTool(ctx) {
         );
       }
       const attendees = await withRequester(ctx, input.attendees);
-      requireAllowedEmails(attendees, ctx.allowedDomains);
-      const response = await googleApiRequest(ctx, {
-        body: {
-          items: attendees.map((id) => ({ id })),
-          timeMax: new Date(timeMaxMs).toISOString(),
-          timeMin: new Date(timeMinMs).toISOString()
-        },
-        operation: "google.calendar.freebusy.query",
-        path: "/calendar/v3/freeBusy"
-      });
+      const required = new Set(attendees);
+      const optionalAttendees = [...new Set(input.optionalAttendees)].filter(
+        (email) => !required.has(email)
+      );
+      const everyone = [...attendees, ...optionalAttendees];
+      requireAllowedEmails(everyone, ctx.allowedDomains);
+      const [response, ...timeZones] = await Promise.all([
+        googleApiRequest(ctx, {
+          body: {
+            items: everyone.map((id) => ({ id })),
+            timeMax: new Date(timeMaxMs).toISOString(),
+            timeMin: new Date(timeMinMs).toISOString()
+          },
+          operation: "google.calendar.freebusy.query",
+          path: "/calendar/v3/freeBusy"
+        }),
+        ...everyone.map((email) => calendarTimeZone(ctx, email))
+      ]);
       if (response.status !== 200) {
         throw googleApiError("google.calendar.freebusy.query", response);
       }
       const { calendars } = freeBusyResponseSchema.parse(response.body);
       const checked = [];
       const unavailable2 = [];
-      const busy = [];
-      for (const email of attendees) {
+      const slotAttendees = [];
+      everyone.forEach((email, index) => {
         const calendar = calendars[email];
         const error = calendar?.errors?.[0]?.reason;
         if (!calendar || error) {
           unavailable2.push({ email, reason: error ?? "notFound" });
-          continue;
+          return;
         }
-        checked.push(email);
-        for (const interval of calendar.busy) {
-          busy.push({
+        const calendarZone = timeZones[index];
+        checked.push({
+          email,
+          ...calendarZone ? { timeZone: calendarZone } : void 0
+        });
+        slotAttendees.push({
+          busy: calendar.busy.map((interval) => ({
             endMs: Date.parse(interval.end),
             startMs: Date.parse(interval.start)
-          });
-        }
-      }
-      const slots = checked.length === 0 ? [] : findFreeSlots({
-        busy,
+          })),
+          email,
+          required: required.has(email),
+          timeZone: calendarZone ?? timeZone
+        });
+      });
+      const slots = !slotAttendees.some((attendee) => attendee.required) ? [] : findFreeSlots({
+        attendees: slotAttendees,
         durationMinutes: input.durationMinutes,
         maxResults: input.maxResults,
         timeMaxMs,
         timeMinMs,
-        timeZone: input.timeZone,
+        timeZone,
         workdayEnd: input.workdayEnd,
         workdayStart: input.workdayStart
       });
+      const otherTimeZones = [
+        ...new Set(slotAttendees.map((attendee) => attendee.timeZone))
+      ].filter((zone) => zone !== timeZone);
       return {
         target: "findMeetingTimes",
         checked,
         slots: slots.map((slot) => ({
           end: new Date(slot.endMs).toISOString(),
-          label: formatInterval(slot.startMs, slot.endMs, input.timeZone),
+          label: formatInterval(slot.startMs, slot.endMs, timeZone),
+          ...otherTimeZones.length ? {
+            otherTimeZoneLabels: otherTimeZones.map(
+              (zone) => formatInterval(slot.startMs, slot.endMs, zone)
+            )
+          } : void 0,
+          ...slot.optionalConflicts.length ? { optionalConflicts: slot.optionalConflicts } : void 0,
           start: new Date(slot.startMs).toISOString()
         })),
-        timeZone: input.timeZone,
+        timeZone,
         unavailable: unavailable2
       };
     }
@@ -1135,61 +1499,70 @@ function createFindMeetingTimesTool(ctx) {
 
 // src/tools/list-events.ts
 import {
-  definePluginTool as definePluginTool3,
+  definePluginTool as definePluginTool4,
   PluginToolInputError as PluginToolInputError4,
-  pluginToolOutputSchema as pluginToolOutputSchema3
+  pluginToolOutputSchema as pluginToolOutputSchema4
 } from "@sentry/junior-plugin-api";
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 var MAX_WINDOW_MS2 = 31 * 24 * 60 * 60 * 1e3;
-var inputSchema3 = z5.object({
-  calendar: z5.string().trim().toLowerCase().pipe(z5.email()).describe("Email address of the person whose calendar to read."),
-  timeMin: z5.iso.datetime({ offset: true }).describe("Start of the window, RFC 3339 with offset."),
-  timeMax: z5.iso.datetime({ offset: true }).describe(
+var inputSchema4 = z6.object({
+  calendar: z6.string().trim().toLowerCase().pipe(z6.email()).optional().describe(
+    "Email address of the person whose calendar to read. Omit to read Junior's own calendar, which holds every event Junior organizes."
+  ),
+  timeMin: z6.iso.datetime({ offset: true }).describe("Start of the window, RFC 3339 with offset."),
+  timeMax: z6.iso.datetime({ offset: true }).describe(
     "End of the window, RFC 3339 with offset. At most 31 days after timeMin."
   ),
   timeZone: timeZoneSchema,
-  maxResults: z5.number().int().min(1).max(100).default(50)
+  maxResults: z6.number().int().min(1).max(100).default(50)
 }).strict();
-var eventSchema = z5.object({
-  attendees: z5.array(z5.string()).optional(),
-  end: z5.string(),
-  eventId: z5.string(),
-  label: z5.string(),
-  location: z5.string().optional(),
-  organizer: z5.string().optional(),
-  start: z5.string(),
-  title: z5.string().optional(),
-  url: z5.string().optional(),
-  videoCallUrl: z5.string().optional()
+var eventSchema = z6.object({
+  attendees: z6.array(attendeeOutputSchema).optional(),
+  end: z6.string(),
+  eventId: z6.string(),
+  label: z6.string(),
+  location: z6.string().optional(),
+  organizer: z6.string().optional(),
+  organizedByJunior: z6.boolean().describe(
+    "True when Junior organizes the event, so Junior can change or cancel it with this eventId."
+  ),
+  seriesEventId: z6.string().optional().describe(
+    "Set when this is one occurrence of a repeating event. It is the id of the whole series."
+  ),
+  start: z6.string(),
+  title: z6.string().optional(),
+  url: z6.string().optional(),
+  videoCallUrl: z6.string().optional()
 });
-var outputSchema3 = pluginToolOutputSchema3.extend({
-  target: z5.literal("listCalendarEvents"),
-  calendar: z5.string(),
-  events: z5.array(eventSchema),
-  timeZone: z5.string(),
-  truncated: z5.boolean(),
-  visible: z5.boolean()
+var outputSchema4 = pluginToolOutputSchema4.extend({
+  target: z6.literal("listCalendarEvents"),
+  calendar: z6.string(),
+  events: z6.array(eventSchema),
+  timeZone: z6.string(),
+  truncated: z6.boolean(),
+  visible: z6.boolean()
 });
-var eventTimeSchema = z5.object({
-  date: z5.string().optional(),
-  dateTime: z5.string().optional()
+var eventTimeSchema = z6.object({
+  date: z6.string().optional(),
+  dateTime: z6.string().optional()
 });
-var listResponseSchema = z5.object({
-  items: z5.array(
-    z5.object({
-      attendees: z5.array(z5.object({ email: z5.string() })).optional(),
+var listResponseSchema = z6.object({
+  items: z6.array(
+    z6.object({
+      attendees: z6.array(googleAttendeeSchema).optional(),
       end: eventTimeSchema,
-      hangoutLink: z5.string().optional(),
-      htmlLink: z5.string().optional(),
-      id: z5.string(),
-      location: z5.string().optional(),
-      organizer: z5.object({ email: z5.string().optional() }).optional(),
+      hangoutLink: z6.string().optional(),
+      htmlLink: z6.string().optional(),
+      id: z6.string(),
+      location: z6.string().optional(),
+      organizer: z6.object({ email: z6.string().optional() }).optional(),
+      recurringEventId: z6.string().optional(),
       start: eventTimeSchema,
-      status: z5.string().optional(),
-      summary: z5.string().optional()
+      status: z6.string().optional(),
+      summary: z6.string().optional()
     })
   ).default([]),
-  nextPageToken: z5.string().optional()
+  nextPageToken: z6.string().optional()
 });
 function lastAllDayDate(end) {
   if (!end.date) return void 0;
@@ -1210,17 +1583,18 @@ function eventLabel(start, end, timeZone) {
   return last && last !== first ? `${first} to ${last}, all day` : `${first}, all day`;
 }
 function createListCalendarEventsTool(ctx) {
-  return definePluginTool3({
+  return definePluginTool4({
     annotations: {
       destructiveHint: false,
       idempotentHint: true,
       openWorldHint: true,
       readOnlyHint: true
     },
-    description: "List events on a colleague's Google Calendar, as seen by Junior's own Google account. Shows titles, times, locations, organizer, and attendees when the calendar's sharing settings allow it. Events without a title are busy blocks the owner did not share. Only calendars in the company's Google Workspace domains can be read. Calendar details can be private: share only what the requester needs, and avoid repeating them in public channels.",
-    inputSchema: inputSchema3,
-    outputSchema: outputSchema3,
+    description: "List events on a colleague's Google Calendar or on Junior's own calendar, as seen by Junior's own Google account. Shows titles, times, locations, organizer, and attendee responses when the calendar's sharing settings allow it. Use it to find an event to change or cancel, check who accepted, or see what someone has coming up. Events without a title are busy blocks the owner did not share. Only calendars in the company's Google Workspace domains can be read. Calendar details can be private: share only what the requester needs, and avoid repeating them in public channels.",
+    inputSchema: inputSchema4,
+    outputSchema: outputSchema4,
     async execute(input) {
+      const timeZone = input.timeZone ?? await ctx.users.resolveTimezone();
       const timeMinMs = Date.parse(input.timeMin);
       const timeMaxMs = Date.parse(input.timeMax);
       if (timeMaxMs <= timeMinMs) {
@@ -1229,23 +1603,24 @@ function createListCalendarEventsTool(ctx) {
       if (timeMaxMs - timeMinMs > MAX_WINDOW_MS2) {
         throw new PluginToolInputError4("Read at most 31 days at a time.");
       }
-      requireAllowedEmails([input.calendar], ctx.allowedDomains);
+      const calendar = input.calendar ?? ctx.accountEmail;
+      requireAllowedEmails([calendar], ctx.allowedDomains);
       const response = await googleApiRequest(ctx, {
         operation: "google.calendar.events.list",
-        path: `/calendar/v3/calendars/${encodeURIComponent(input.calendar)}/events`,
+        path: `/calendar/v3/calendars/${calendar === ctx.accountEmail ? "primary" : encodeURIComponent(calendar)}/events`,
         query: {
           maxResults: String(input.maxResults),
           orderBy: "startTime",
           singleEvents: "true",
           timeMax: new Date(timeMaxMs).toISOString(),
           timeMin: new Date(timeMinMs).toISOString(),
-          timeZone: input.timeZone
+          timeZone
         }
       });
       const result = {
         target: "listCalendarEvents",
-        calendar: input.calendar,
-        timeZone: input.timeZone
+        calendar,
+        timeZone
       };
       if (response.status === 404) {
         return { ...result, events: [], truncated: false, visible: false };
@@ -1259,12 +1634,14 @@ function createListCalendarEventsTool(ctx) {
         events: items.filter((event) => event.status !== "cancelled").map((event) => ({
           end: event.end.dateTime ?? lastAllDayDate(event.end) ?? "",
           eventId: event.id,
-          label: eventLabel(event.start, event.end, input.timeZone),
+          label: eventLabel(event.start, event.end, timeZone),
           start: event.start.dateTime ?? event.start.date ?? "",
           ...event.summary ? { title: event.summary } : void 0,
           ...event.location ? { location: event.location } : void 0,
           ...event.organizer?.email ? { organizer: event.organizer.email } : void 0,
-          ...event.attendees ? { attendees: event.attendees.map((person) => person.email) } : void 0,
+          organizedByJunior: event.organizer?.email?.toLowerCase() === ctx.accountEmail,
+          ...event.recurringEventId ? { seriesEventId: event.recurringEventId } : void 0,
+          ...event.attendees ? { attendees: attendeeResults(event.attendees) } : void 0,
           ...event.htmlLink ? { url: event.htmlLink } : void 0,
           ...event.hangoutLink ? { videoCallUrl: event.hangoutLink } : void 0
         })),
@@ -1277,39 +1654,42 @@ function createListCalendarEventsTool(ctx) {
 
 // src/tools/update-event.ts
 import {
-  definePluginTool as definePluginTool4,
+  definePluginTool as definePluginTool5,
   PluginToolInputError as PluginToolInputError5,
-  pluginToolOutputSchema as pluginToolOutputSchema4
+  pluginToolOutputSchema as pluginToolOutputSchema5
 } from "@sentry/junior-plugin-api";
-import { z as z6 } from "zod";
-var inputSchema4 = z6.object({
-  eventId: z6.string().regex(/^[A-Za-z0-9_]{5,1024}$/, "Use an event id from a Calendar tool").describe(
-    "Event id from createCalendarEvent or listCalendarEvents. Only events that Junior organizes can be changed."
-  ),
-  title: z6.string().trim().min(1).max(200).optional(),
-  description: z6.string().max(4e3).optional().describe(
+import { z as z7 } from "zod";
+var inputSchema5 = z7.object({
+  eventId: ownEventIdSchema,
+  title: z7.string().trim().min(1).max(200).optional(),
+  description: z7.string().max(4e3).optional().describe(
     "Replacement description. Do not include private details the attendees should not see."
   ),
-  start: z6.iso.datetime({ offset: true }).optional().describe("New start, RFC 3339 with offset. Give end too."),
-  end: z6.iso.datetime({ offset: true }).optional().describe("New end, RFC 3339 with offset. Give start too."),
+  start: z7.iso.datetime({ offset: true }).optional().describe("New start, RFC 3339 with offset. Give end too."),
+  end: z7.iso.datetime({ offset: true }).optional().describe("New end, RFC 3339 with offset. Give start too."),
   timeZone: timeZoneSchema,
-  addAttendees: emailListSchema(50).default([]).describe("Email addresses to invite."),
-  removeAttendees: emailListSchema(50).default([]).describe("Email addresses to remove from the event.")
+  location: z7.string().trim().max(500).optional().describe(
+    "Replacement location, such as a room name or address. Use an empty string to clear it."
+  ),
+  addAttendees: emailListSchema(50).default([]).describe("Email addresses to invite as required attendees."),
+  addOptionalAttendees: emailListSchema(50).default([]).describe("Email addresses to invite as optional attendees."),
+  removeAttendees: emailListSchema(50).default([]).describe("Email addresses to remove from the event."),
+  addVideoCall: z7.literal(true).optional().describe("Add a Google Meet link when the event has none.")
 }).strict().refine(
   (input) => input.start === void 0 === (input.end === void 0),
   {
     message: "Give both start and end to move an event."
   }
 ).refine(
-  (input) => input.title !== void 0 || input.description !== void 0 || input.start !== void 0 || input.addAttendees.length > 0 || input.removeAttendees.length > 0,
+  (input) => input.title !== void 0 || input.description !== void 0 || input.start !== void 0 || input.location !== void 0 || input.addVideoCall !== void 0 || input.addAttendees.length > 0 || input.addOptionalAttendees.length > 0 || input.removeAttendees.length > 0,
   { message: "Give at least one change." }
 );
-var outputSchema4 = pluginToolOutputSchema4.extend({
-  target: z6.literal("updateCalendarEvent"),
+var outputSchema5 = pluginToolOutputSchema5.extend({
+  target: z7.literal("updateCalendarEvent"),
   ...ownEventOutputFields
 });
 function createUpdateCalendarEventTool(ctx) {
-  return definePluginTool4({
+  return definePluginTool5({
     annotations: {
       destructiveHint: false,
       idempotentHint: true,
@@ -1321,15 +1701,19 @@ function createUpdateCalendarEventTool(ctx) {
         input.title && `rename it to "${input.title}"`,
         input.start && `move it to ${input.start} \u2013 ${input.end}`,
         input.description !== void 0 && "replace the description",
+        input.location !== void 0 && (input.location ? `set the location to ${input.location}` : "clear the location"),
+        input.addVideoCall && "add a Google Meet link",
         input.addAttendees.length > 0 && `invite ${input.addAttendees.join(", ")}`,
+        input.addOptionalAttendees.length > 0 && `invite ${input.addOptionalAttendees.join(", ")} as optional`,
         input.removeAttendees.length > 0 && `remove ${input.removeAttendees.join(", ")}`
       ].filter(Boolean);
       return `Update Google Calendar event ${input.eventId}: ${changes.join("; ")}. Attendees get an email about the change.`;
     },
-    description: "Change a Google Calendar event organized by Junior's own Google account: title, description, time, or attendees. Google emails the attendees about the change. Only people invited to the event can ask for changes, and only people in the company's Google Workspace domains can be invited. Use after the requester confirms the change.",
-    inputSchema: inputSchema4,
-    outputSchema: outputSchema4,
+    description: "Change a Google Calendar event organized by Junior's own Google account: title, description, time, location, video call, or attendees. Use it to reschedule, add or remove people, or fix details. Google emails the attendees about the change, and existing attendees keep their responses. Only people invited to the event can ask for changes, and only people in the company's Google Workspace domains can be invited. Junior cannot change events other people organize. For a repeating event, an occurrence id changes only that occurrence; its seriesEventId changes every occurrence. Confirm the change with the requester first unless they already stated it exactly.",
+    inputSchema: inputSchema5,
+    outputSchema: outputSchema5,
     async execute(input) {
+      const timeZone = input.timeZone ?? await ctx.users.resolveTimezone();
       if (input.start && input.end) {
         const durationMs = Date.parse(input.end) - Date.parse(input.start);
         if (durationMs <= 0) {
@@ -1339,39 +1723,19 @@ function createUpdateCalendarEventTool(ctx) {
           throw new PluginToolInputError5("Events can be at most 8 hours long.");
         }
       }
-      requireAllowedEmails(input.addAttendees, ctx.allowedDomains);
-      const requester = await requesterEmail(ctx);
-      if (!requester) {
-        throw new PluginToolInputError5(
-          "Junior does not know the requester's email, so it cannot check that they may change this event."
-        );
-      }
-      const path = `/calendar/v3/calendars/primary/events/${input.eventId}`;
-      const current = await googleApiRequest(ctx, {
-        operation: "google.calendar.event.get",
-        path
-      });
-      if (current.status === 404) {
-        throw new PluginToolInputError5(
-          `Junior's calendar has no event ${input.eventId}.`
-        );
-      }
-      if (current.status !== 200) {
-        throw googleApiError("google.calendar.event.get", current);
-      }
-      const event = ownEventSchema.parse(current.body);
-      if (event.organizer?.self !== true) {
+      requireAllowedEmails(
+        [...input.addAttendees, ...input.addOptionalAttendees],
+        ctx.allowedDomains
+      );
+      const read = await readOwnEventForRequester(ctx, input.eventId, "change");
+      if (read.status === "cancelled") {
         throw new PluginToolInputError5(
-          "Junior does not organize this event, so it cannot change it."
+          "This event is cancelled. Create a new event instead."
         );
       }
+      const { event, path } = read;
       const attendees = event.attendees ?? [];
       const emailKey = (email) => email.toLowerCase();
-      if (!attendees.some((attendee) => emailKey(attendee.email) === requester)) {
-        throw new PluginToolInputError5(
-          "Only people invited to this event can ask Junior to change it."
-        );
-      }
       const removed = new Set(input.removeAttendees);
       const kept = attendees.filter(
         (attendee) => !removed.has(emailKey(attendee.email))
@@ -1379,8 +1743,19 @@ function createUpdateCalendarEventTool(ctx) {
       const existing = new Set(
         kept.map((attendee) => emailKey(attendee.email))
       );
-      const added = input.addAttendees.filter((email) => !existing.has(email)).map((email) => ({ email }));
+      const added = [
+        ...input.addAttendees.map((email) => ({ email })),
+        ...input.addOptionalAttendees.map((email) => ({
+          email,
+          optional: true
+        }))
+      ].filter((attendee) => {
+        if (existing.has(attendee.email)) return false;
+        existing.add(attendee.email);
+        return true;
+      });
       const attendeesChanged = kept.length !== attendees.length || added.length;
+      const addVideoCall = input.addVideoCall && !event.hangoutLink;
       const response = await googleApiRequest(ctx, {
         body: {
           ...input.title !== void 0 && { summary: input.title },
@@ -1388,21 +1763,33 @@ function createUpdateCalendarEventTool(ctx) {
             description: input.description
           },
           ...input.start && input.end && {
-            end: { dateTime: input.end, timeZone: input.timeZone },
-            start: { dateTime: input.start, timeZone: input.timeZone }
+            end: { dateTime: input.end, timeZone },
+            start: { dateTime: input.start, timeZone }
           },
-          ...attendeesChanged && { attendees: [...kept, ...added] }
+          ...input.location !== void 0 && { location: input.location },
+          ...attendeesChanged && { attendees: [...kept, ...added] },
+          ...addVideoCall && {
+            conferenceData: {
+              createRequest: {
+                conferenceSolutionKey: { type: "hangoutsMeet" },
+                requestId: `${event.id}-meet`
+              }
+            }
+          }
         },
         operation: "google.calendar.event.update",
         path,
-        query: { sendUpdates: "all" }
+        query: {
+          ...addVideoCall && { conferenceDataVersion: "1" },
+          sendUpdates: "all"
+        }
       });
       if (response.status !== 200) {
         throw googleApiError("google.calendar.event.update", response);
       }
       return {
         target: "updateCalendarEvent",
-        ...ownEventResult(ownEventSchema.parse(response.body), input.timeZone)
+        ...ownEventResult(ownEventSchema.parse(response.body), timeZone)
       };
     }
   });
@@ -1441,11 +1828,13 @@ function googlePlugin() {
           return {};
         }
         const toolContext = {
+          accountEmail: config.accountEmail,
           allowedDomains: config.allowedDomains,
           egress: ctx.egress,
           users: ctx.users
         };
         return {
+          cancelCalendarEvent: createCancelCalendarEventTool(toolContext),
           createCalendarEvent: createCreateCalendarEventTool(toolContext),
           findMeetingTimes: createFindMeetingTimesTool(toolContext),
           listCalendarEvents: createListCalendarEventsTool(toolContext),