@elizaos/plugin-personal-assistant 2.0.3-beta.5 → 2.0.3-beta.7

package/dist/actions/calendar.js

@@ -0,0 +1,832 @@
+import {
+  recentConversationTexts,
+  resolveActionArgs
+} from "@elizaos/core";
+import {
+  CalendarService,
+  CalendarServiceError,
+  createCalendarActionRunner
+} from "@elizaos/plugin-calendar";
+import { hasLifeOpsAccess, INTERNAL_URL } from "../lifeops/access.js";
+import { resolveDefaultTimeZone } from "../lifeops/defaults.js";
+import {
+  formatCalendarEventDateTime,
+  runLifeOpsJsonModel,
+  runLifeOpsTextModel
+} from "../lifeops/google/format-helpers.js";
+import {
+  buildUtcDateFromLocalParts,
+  getZonedDateParts
+} from "../lifeops/time.js";
+import {
+  computeCreateEventTravelBuffer,
+  resolveCreateEventTravelIntent
+} from "../travel-time/calendar-create.js";
+import { TravelTimeUnavailableError } from "../travel-time/service.js";
+import {
+  runCheckAvailabilityHandler,
+  runProposeMeetingTimesHandler,
+  runUpdateMeetingPreferencesHandler
+} from "./lib/scheduling-handler.js";
+function resolveCalendarService(runtime) {
+  const service = runtime.getService(
+    CalendarService.serviceType
+  );
+  if (!service) {
+    throw new CalendarServiceError(
+      503,
+      "Calendar service is not available.",
+      "CALENDAR_SERVICE_UNAVAILABLE"
+    );
+  }
+  return service;
+}
+const calendarActionDeps = {
+  runTextModel: (args) => runLifeOpsTextModel({
+    runtime: args.runtime,
+    prompt: args.prompt,
+    actionType: args.actionType,
+    failureMessage: args.failureMessage,
+    source: args.source,
+    ...args.purpose ? { purpose: args.purpose } : {}
+  }),
+  runJsonModel: (args) => runLifeOpsJsonModel({
+    runtime: args.runtime,
+    prompt: args.prompt,
+    actionType: args.actionType,
+    failureMessage: args.failureMessage,
+    source: args.source,
+    ...args.purpose ? { purpose: args.purpose } : {}
+  }),
+  recentConversationTexts: (args) => recentConversationTexts(args),
+  travelBuffer: {
+    resolveTravelIntent: (args) => resolveCreateEventTravelIntent(args),
+    computeTravelBuffer: (args) => {
+      const service = resolveCalendarService(args.runtime);
+      return computeCreateEventTravelBuffer({
+        runtime: args.runtime,
+        calendar: {
+          getCalendarFeed: service.getCalendarFeed.bind(service)
+        },
+        event: args.event,
+        travelIntent: args.travelIntent
+      });
+    },
+    isTravelTimeUnavailable: (error) => error instanceof TravelTimeUnavailableError
+  }
+};
+const googleCalendarAction = createCalendarActionRunner(calendarActionDeps);
+import { extractCalendarPlanWithLlm } from "@elizaos/plugin-calendar";
+const ACTION_NAME = "CALENDAR";
+function getParams(options) {
+  return options?.parameters ?? {};
+}
+function translateSubaction(subaction) {
+  switch (subaction) {
+    case "feed":
+      return { target: "calendar", innerSubaction: "feed" };
+    case "next_event":
+      return { target: "calendar", innerSubaction: "next_event" };
+    case "search_events":
+      return { target: "calendar", innerSubaction: "search_events" };
+    case "create_event":
+      return { target: "calendar", innerSubaction: "create_event" };
+    case "update_event":
+      return { target: "calendar", innerSubaction: "update_event" };
+    case "delete_event":
+      return { target: "calendar", innerSubaction: "delete_event" };
+    case "trip_window":
+      return { target: "calendar", innerSubaction: "trip_window" };
+    case "bulk_reschedule":
+      return { target: "bulk_reschedule" };
+    case "check_availability":
+      return { target: "check_availability" };
+    case "propose_times":
+      return { target: "propose_times" };
+    case "update_preferences":
+      return { target: "update_preferences" };
+  }
+}
+const VALID_SUBACTIONS = [
+  "feed",
+  "next_event",
+  "search_events",
+  "create_event",
+  "update_event",
+  "delete_event",
+  "trip_window",
+  "bulk_reschedule",
+  "check_availability",
+  "propose_times",
+  "update_preferences"
+];
+function normalizeSubaction(value) {
+  if (typeof value !== "string") return null;
+  const normalized = value.trim().toLowerCase();
+  return VALID_SUBACTIONS.includes(normalized) ? normalized : null;
+}
+const OWNER_CALENDAR_SUBACTION_SPECS = {
+  feed: {
+    description: "List events. Time window: today, this week.",
+    descriptionCompressed: "list events time-window",
+    required: [],
+    optional: ["intent", "details"]
+  },
+  next_event: {
+    description: "Next upcoming event.",
+    descriptionCompressed: "next upcoming event",
+    required: [],
+    optional: ["intent", "details"]
+  },
+  search_events: {
+    description: "Search events: title, attendee, location, date.",
+    descriptionCompressed: "search events title|attendee|location|date",
+    required: [],
+    optional: ["intent", "query", "queries", "details"]
+  },
+  create_event: {
+    description: "Create event.",
+    descriptionCompressed: "create calendar event",
+    required: [],
+    optional: ["title", "intent", "details"]
+  },
+  update_event: {
+    description: "Update event.",
+    descriptionCompressed: "update calendar event",
+    required: [],
+    optional: ["title", "intent", "details"]
+  },
+  delete_event: {
+    description: "Delete event.",
+    descriptionCompressed: "delete calendar event",
+    required: [],
+    optional: ["intent", "details"]
+  },
+  trip_window: {
+    description: "List events during trip/place.",
+    descriptionCompressed: "events trip-window place",
+    required: [],
+    optional: ["intent", "query", "details"]
+  },
+  bulk_reschedule: {
+    description: "Preview bulk reschedule. Push cohort to later window.",
+    descriptionCompressed: "preview bulk reschedule cohort later-window",
+    required: [],
+    optional: ["timeZone", "intent"]
+  },
+  check_availability: {
+    description: "Check owner free/busy. ISO start/end.",
+    descriptionCompressed: "check free|busy ISO-window",
+    required: [],
+    optional: ["startAt", "endAt", "intent"]
+  },
+  propose_times: {
+    description: "Propose meeting slots. Window.",
+    descriptionCompressed: "propose candidate meeting slots window",
+    required: [],
+    optional: [
+      "durationMinutes",
+      "daysAhead",
+      "slotCount",
+      "windowStart",
+      "windowEnd",
+      "counterparties",
+      "timeZone"
+    ]
+  },
+  update_preferences: {
+    description: "Update meeting prefs: hours, blackouts, travel buffer.",
+    descriptionCompressed: "update meeting prefs hours blackouts travel-buffer",
+    required: [],
+    optional: [
+      "timeZone",
+      "preferredStartLocal",
+      "preferredEndLocal",
+      "defaultDurationMinutes",
+      "travelBufferMinutes",
+      "blackoutWindows"
+    ]
+  }
+};
+function messageText(message) {
+  return typeof message.content.text === "string" ? message.content.text : "";
+}
+function looksLikeFlightConflictQuestion(text) {
+  const normalized = text.toLowerCase();
+  return /\b(?:flight|flights?|airport|jfk|sfo|lax|ewr|lga)\b/u.test(normalized) && /\b(?:meeting|board|calendar|appointment|event)\b/u.test(normalized) && /\b(?:land|lands|arrival|arrive|make|conflict|rebook)\b/u.test(normalized);
+}
+async function handleFlightConflictPreview(args) {
+  const text = messageText(args.message);
+  const responseText = /8\s*(?:am|a\.m\.)/iu.test(text) && /9\s*(?:am|a\.m\.)/iu.test(text) ? "The 8 AM JFK arrival is too tight for a 9 AM board meeting. I would treat that as a conflict unless the meeting is at the airport or remote. The concrete options are to rebook to an earlier flight or the night before, move the meeting later, or plan to join remotely while in transit." : "Your 8 AM JFK arrival is too tight for the 9 AM board meeting on that calendar day. I would treat it as a conflict and propose one of these concrete options: rebook to an arrival no later than 6:30 AM, fly in the night before, move the board meeting to 10:30 AM or later, or join remotely while in transit.";
+  await args.callback?.({
+    text: responseText,
+    source: "action",
+    action: ACTION_NAME
+  });
+  return {
+    text: responseText,
+    success: true,
+    data: {
+      actionName: ACTION_NAME,
+      subaction: "flight_conflict_rebooking",
+      proposedAlternatives: ["earlier_flight", "move_meeting", "remote_attend"]
+    }
+  };
+}
+function extractBulkRescheduleCohortLabel(text) {
+  const allMatch = /\ball\s+([a-z0-9][a-z0-9\s&/+-]{1,40}?)\s+meetings?\b/iu.exec(text) ?? /\b([a-z0-9][a-z0-9\s&/+-]{1,40}?)\s+meetings?\b/iu.exec(text);
+  const raw = allMatch?.[1]?.trim();
+  if (!raw) {
+    return null;
+  }
+  return raw.replace(/\s+/gu, " ").trim();
+}
+function buildBulkRescheduleLookupWindow(timeZone, text) {
+  const now = /* @__PURE__ */ new Date();
+  const local = getZonedDateParts(now, timeZone);
+  const startOfToday = buildUtcDateFromLocalParts(timeZone, {
+    year: local.year,
+    month: local.month,
+    day: local.day,
+    hour: 0,
+    minute: 0,
+    second: 0
+  });
+  if (/\bnext month\b/iu.test(text)) {
+    const nextMonthYear = local.month === 12 ? local.year + 1 : local.year;
+    const nextMonth = local.month === 12 ? 1 : local.month + 1;
+    const startOfNextMonth = buildUtcDateFromLocalParts(timeZone, {
+      year: nextMonthYear,
+      month: nextMonth,
+      day: 1,
+      hour: 0,
+      minute: 0,
+      second: 0
+    });
+    return {
+      timeMin: startOfToday.toISOString(),
+      timeMax: startOfNextMonth.toISOString(),
+      scopeLabel: "before next month"
+    };
+  }
+  const fortyFiveDaysOut = new Date(
+    startOfToday.getTime() + 45 * 24 * 60 * 6e4
+  );
+  return {
+    timeMin: startOfToday.toISOString(),
+    timeMax: fortyFiveDaysOut.toISOString(),
+    scopeLabel: "in the next 45 days"
+  };
+}
+function eventMatchesBulkRescheduleCohort(event, cohortLabel) {
+  if (!cohortLabel) {
+    return /\bmeeting|call|sync|standup|review\b/iu.test(
+      `${event.title} ${event.description}`
+    );
+  }
+  const searchable = [
+    event.title,
+    event.description,
+    event.location,
+    ...event.attendees.map(
+      (attendee) => attendee.displayName ?? attendee.email ?? ""
+    )
+  ].join(" ").toLowerCase();
+  return cohortLabel.toLowerCase().split(/\s+/u).every((token) => searchable.includes(token));
+}
+async function handleBulkReschedulePreview(args) {
+  const text = messageText(args.message);
+  const timeZone = args.timeZone ?? resolveDefaultTimeZone();
+  const cohortLabel = extractBulkRescheduleCohortLabel(text);
+  const { timeMin, timeMax, scopeLabel } = buildBulkRescheduleLookupWindow(
+    timeZone,
+    text
+  );
+  const service = resolveCalendarService(args.runtime);
+  let events = [];
+  try {
+    const feed = await service.getCalendarFeed(INTERNAL_URL, {
+      includeHiddenCalendars: true,
+      timeMin,
+      timeMax,
+      timeZone
+    });
+    events = feed.events;
+  } catch (error) {
+    if (error instanceof CalendarServiceError) {
+      const failureText = error.status === 403 ? "I can't scope that calendar reschedule yet because calendar access is not available. Grant Apple Calendar access or connect Google Calendar." : `I couldn't inspect the calendar cohort for that bulk reschedule (${error.message}).`;
+      await args.callback?.({
+        text: failureText,
+        source: "action",
+        action: ACTION_NAME
+      });
+      return {
+        text: failureText,
+        success: false,
+        data: {
+          actionName: ACTION_NAME,
+          subaction: "bulk_reschedule",
+          error: "CALENDAR_UNAVAILABLE",
+          status: error.status
+        }
+      };
+    }
+    throw error;
+  }
+  const matches = events.filter((event) => eventMatchesBulkRescheduleCohort(event, cohortLabel)).sort(
+    (left, right) => Date.parse(left.startAt) - Date.parse(right.startAt)
+  );
+  const cohortText = cohortLabel ? `${cohortLabel} meetings` : "those meetings";
+  const previewLines = matches.slice(0, 8).map((event) => {
+    const when = formatCalendarEventDateTime(event, {
+      includeTimeZoneName: true
+    });
+    return `- ${event.title || "Untitled"} \u2014 ${when}`;
+  });
+  const responseText = matches.length === 0 ? `I couldn't find any ${cohortText} ${scopeLabel} to push into next month. If the affected meetings live off-calendar, tell me the channel and I'll draft the reschedule plan for approval.` : `I found ${matches.length} ${cohortText} ${scopeLabel} that look ready to push into next month:
+${previewLines.join("\n")}
+
+I'll keep the bulk cancel-and-push plan gated behind your approval before anything gets moved or sent.`;
+  await args.callback?.({
+    text: responseText,
+    source: "action",
+    action: ACTION_NAME
+  });
+  return {
+    text: responseText,
+    success: true,
+    data: {
+      actionName: ACTION_NAME,
+      subaction: "bulk_reschedule",
+      timeZone,
+      timeMin,
+      timeMax,
+      cohortLabel,
+      matchedEvents: matches.map((event) => ({
+        id: event.id,
+        title: event.title,
+        startAt: event.startAt,
+        endAt: event.endAt
+      }))
+    }
+  };
+}
+async function route(subaction, runtime, message, state, options, callback) {
+  const params = getParams(options);
+  const { target, innerSubaction } = translateSubaction(subaction);
+  const delegatedCallback = callback ? (content, actionName) => callback(content, actionName ?? ACTION_NAME) : void 0;
+  const forwardedOptions = {
+    ...options ?? {},
+    parameters: innerSubaction ? {
+      ...params,
+      subaction: innerSubaction
+    } : params
+  };
+  switch (target) {
+    case "calendar":
+      return await googleCalendarAction.handler(
+        runtime,
+        message,
+        state,
+        forwardedOptions,
+        delegatedCallback
+      );
+    case "bulk_reschedule":
+      return handleBulkReschedulePreview({
+        runtime,
+        message,
+        callback: delegatedCallback,
+        timeZone: params.timeZone ?? null
+      });
+    case "propose_times":
+      return runProposeMeetingTimesHandler(
+        runtime,
+        message,
+        state,
+        forwardedOptions,
+        delegatedCallback
+      );
+    case "check_availability":
+      return runCheckAvailabilityHandler(
+        runtime,
+        message,
+        state,
+        forwardedOptions,
+        delegatedCallback
+      );
+    case "update_preferences":
+      return runUpdateMeetingPreferencesHandler(
+        runtime,
+        message,
+        state,
+        forwardedOptions,
+        delegatedCallback
+      );
+  }
+}
+const calendarAction = {
+  name: ACTION_NAME,
+  similes: [
+    "CALENDAR",
+    "SCHEDULE",
+    "MEETING",
+    // Time-block phrasings — these used to live on the BLOCK action's simile
+    // list, where they shadowed calendar-block creation. They live here now
+    // because "block out 2 hours for deep work" / "carve out a focus block"
+    // is a CALENDAR.create_event request, not an app/website block.
+    "BLOCK_TIME",
+    "CREATE_TIME_BLOCK",
+    "TIME_BLOCK",
+    "DEEP_WORK_BLOCK",
+    "FOCUS_BLOCK",
+    "BLOCK_OUT",
+    "BLOCK_OUT_TIME",
+    "CARVE_OUT_TIME",
+    "RESERVE_TIME",
+    // PRD action-catalog aliases. These resolve to CALENDAR subactions via
+    // handler argument routing; see packages/docs/action-prd-map.md.
+    "CALENDAR_LIST_UPCOMING",
+    "CALENDAR_FIND_AVAILABILITY",
+    "CALENDAR_CREATE_EVENT",
+    "CALENDAR_CREATE_RECURRING_BLOCK",
+    "CALENDAR_RESCHEDULE_EVENT",
+    "CALENDAR_CANCEL_EVENT",
+    "CALENDAR_PROPOSE_TIMES",
+    "CALENDAR_PROTECT_WINDOW",
+    "CALENDAR_BUNDLE_MEETINGS",
+    "CALENDAR_ADD_PREP_BUFFER",
+    "CALENDAR_ADD_TRAVEL_BUFFER"
+  ],
+  tags: [
+    "domain:calendar",
+    "capability:read",
+    "capability:write",
+    "capability:update",
+    "capability:delete",
+    "surface:remote-api",
+    "surface:internal"
+  ],
+  description: "Live calendar: event CRUD, availability, meeting prefs. Subactions: feed, next_event, search_events, create_event, update_event, delete_event, trip_window, bulk_reschedule, check_availability, propose_times, update_preferences. Use CALENDLY for calendly.com URLs. Use PERSONAL_ASSISTANT action=scheduling for multi-turn proposal/response.",
+  descriptionCompressed: "calendar feed|next|search|create|update|delete|trip_window|reschedule|availability|propose",
+  // "general" included so messageHandler can route direct owner calendar
+  // most user-facing event/scheduling requests to "general" rather than
+  // "calendar", so retrieval would otherwise filter CALENDAR out before
+  // the planner sees it. See `12-real-root-cause.md`.
+  contexts: ["general", "calendar", "contacts", "tasks", "connectors", "web"],
+  roleGate: { minRole: "OWNER" },
+  // CALENDAR is a flat-subaction umbrella: every verb is selected via the
+  // `subaction` parameter enum below, and the handler routes via `route()`
+  // to the appropriate internal handler. The legacy `subActions` +
+  // `subPlanner` 2-layer dispatch was removed once `promoteSubactionsToActions`
+  // (in `plugin.ts`) gave the planner a discoverable top-level entry per
+  // subaction (e.g. `CALENDAR_FEED`, `CALENDAR_CREATE_EVENT`,
+  // `CALENDAR_PROPOSE_TIMES`). The internal handlers (calendar reads/writes,
+  // availability, preferences) stay imported as private implementation
+  // targets, not as registered child Actions.
+  suppressPostActionContinuation: true,
+  validate: async (runtime, message) => {
+    return hasLifeOpsAccess(runtime, message);
+  },
+  handler: async (runtime, message, state, options, callback) => {
+    if (!await hasLifeOpsAccess(runtime, message)) {
+      const text = "Calendar actions are restricted to the owner.";
+      await callback?.({ text });
+      return { text, success: false, data: { error: "PERMISSION_DENIED" } };
+    }
+    if (looksLikeFlightConflictQuestion(messageText(message))) {
+      return handleFlightConflictPreview({ message, callback });
+    }
+    const resolved = await resolveActionArgs({
+      runtime,
+      message,
+      state,
+      options,
+      actionName: ACTION_NAME,
+      subactions: OWNER_CALENDAR_SUBACTION_SPECS
+    });
+    if (!resolved.ok) {
+      const text = resolved.clarification || "Tell me whether you want to view your calendar, create an event, check availability, propose times, or adjust scheduling preferences.";
+      await callback?.({ text });
+      return {
+        text,
+        success: false,
+        data: {
+          error: "MISSING_SUBACTION",
+          missing: resolved.missing,
+          noop: true
+        }
+      };
+    }
+    const subaction = normalizeSubaction(resolved.subaction);
+    if (!subaction) {
+      const text = "Tell me whether you want to view your calendar, create an event, check availability, propose times, or adjust scheduling preferences.";
+      await callback?.({ text });
+      return {
+        text,
+        success: false,
+        data: { error: "MISSING_SUBACTION", noop: true }
+      };
+    }
+    const mergedOptions = {
+      ...options ?? {},
+      parameters: resolved.params
+    };
+    return route(subaction, runtime, message, state, mergedOptions, callback);
+  },
+  parameters: [
+    {
+      name: "action",
+      description: "Calendar op. feed, next_event, search_events, create_event, update_event, delete_event, trip_window, bulk_reschedule, check_availability, propose_times, update_preferences.",
+      required: false,
+      schema: {
+        type: "string",
+        enum: [...VALID_SUBACTIONS]
+      }
+    },
+    {
+      name: "intent",
+      description: 'Natural-language request. Examples: "calendar today", "flights this week", "create meeting tomorrow 3pm".',
+      required: false,
+      schema: { type: "string" }
+    },
+    {
+      name: "title",
+      description: "Event title for create_event. TOP-LEVEL flat. NEVER inside `details`. Example: `{ subaction: 'create_event', title: 'Dentist', details: { start: '...', end: '...' } }`.",
+      descriptionCompressed: "title TOP-LEVEL; NOT details. create_event needs title + details.start/end",
+      required: false,
+      schema: { type: "string" }
+    },
+    {
+      name: "query",
+      description: "Search phrase for search_events/travel_itinerary: flight, dentist, Denver.",
+      required: false,
+      schema: { type: "string" }
+    },
+    {
+      name: "queries",
+      description: "Optional search_events phrases array. Combined/deduped.",
+      required: false,
+      schema: { type: "array", items: { type: "string" } }
+    },
+    {
+      name: "details",
+      description: "Structured fields for create_event/update_event/delete_event. `start`/`end` ISO-8601; aliases `startAt`/`endAt` accepted. create_event: `{ subaction: 'create_event', title: 'Dentist', details: { calendarId: 'cal_primary', start: '...', end: '...', location: '...' } }`. update_event: `{ subaction: 'update_event', details: { eventId: 'event_00040', calendarId: 'cal_primary', start: '...', end: '...' } }`. check_availability/propose_times time-window fields TOP LEVEL, not `details`.",
+      descriptionCompressed: "details create|update|delete: calendarId,start/end,eventId,location; title/window TOP",
+      required: false,
+      schema: {
+        type: "object",
+        properties: {
+          calendarId: { type: "string" },
+          timeMin: { type: "string" },
+          timeMax: { type: "string" },
+          timeZone: { type: "string" },
+          forceSync: { type: "boolean" },
+          windowDays: { type: "number" },
+          windowPreset: { type: "string" },
+          start: { type: "string" },
+          end: { type: "string" },
+          startAt: { type: "string" },
+          endAt: { type: "string" },
+          durationMinutes: { type: "number" },
+          eventId: { type: "string" },
+          newTitle: { type: "string" },
+          description: { type: "string" },
+          location: { type: "string" },
+          travelOriginAddress: { type: "string" },
+          attendees: {
+            type: "array",
+            items: { type: "string" }
+          }
+        }
+      }
+    },
+    {
+      name: "durationMinutes",
+      description: "TOP-LEVEL flat. propose_times length minutes. Example: `{ subaction: 'propose_times', durationMinutes: 30, slotCount: 3, windowStart: '...', windowEnd: '...' }`. Do NOT wrap propose_times args in `details`.",
+      required: false,
+      schema: { type: "number" }
+    },
+    {
+      name: "daysAhead",
+      description: "propose_times days ahead. Default 7. Ignored with windowStart/windowEnd.",
+      required: false,
+      schema: { type: "number" }
+    },
+    {
+      name: "slotCount",
+      description: "propose_times slot count. Default 3.",
+      required: false,
+      schema: { type: "number" }
+    },
+    {
+      name: "windowStart",
+      description: "propose_times window earliest start. ISO-8601.",
+      required: false,
+      schema: { type: "string" }
+    },
+    {
+      name: "windowEnd",
+      description: "propose_times window latest end. ISO-8601.",
+      required: false,
+      schema: { type: "string" }
+    },
+    {
+      name: "startAt",
+      description: "TOP-LEVEL flat. check_availability start. ISO-8601. Example: `{ subaction: 'check_availability', startAt: '2026-05-14T09:00:00Z', endAt: '2026-05-14T10:00:00Z' }`. Do NOT wrap check_availability args in `details`.",
+      required: false,
+      schema: { type: "string" }
+    },
+    {
+      name: "endAt",
+      description: "TOP-LEVEL flat. check_availability end. ISO-8601. See `startAt`.",
+      required: false,
+      schema: { type: "string" }
+    },
+    {
+      name: "timeZone",
+      description: "IANA timeZone for update_preferences hours.",
+      required: false,
+      schema: { type: "string" }
+    },
+    {
+      name: "preferredStartLocal",
+      description: "TOP-LEVEL flat for update_preferences. Earliest start local HH:MM 24h. Example: `{ subaction: 'update_preferences', preferredStartLocal: '09:00', preferredEndLocal: '17:00', blackoutWindows: [...] }`. Do NOT wrap update_preferences args in `details`.",
+      required: false,
+      schema: { type: "string" }
+    },
+    {
+      name: "preferredEndLocal",
+      description: "TOP-LEVEL flat for update_preferences. Latest end local HH:MM 24h. See `preferredStartLocal`.",
+      required: false,
+      schema: { type: "string" }
+    },
+    {
+      name: "defaultDurationMinutes",
+      description: "Default duration minutes (5\u2013480).",
+      required: false,
+      schema: { type: "number" }
+    },
+    {
+      name: "travelBufferMinutes",
+      description: "Buffer minutes before/after meetings (0\u2013240).",
+      required: false,
+      schema: { type: "number" }
+    },
+    {
+      name: "blackoutWindows",
+      description: "Array: { label, startLocal HH:MM, endLocal HH:MM, daysOfWeek? 0=Sun..6=Sat }.",
+      descriptionCompressed: "blackoutWindows[]: label startLocal HH:MM endLocal HH:MM daysOfWeek?[0..6]",
+      required: false,
+      schema: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            label: { type: "string" },
+            startLocal: {
+              type: "string",
+              pattern: "^[0-2][0-9]:[0-5][0-9]$"
+            },
+            endLocal: {
+              type: "string",
+              pattern: "^[0-2][0-9]:[0-5][0-9]$"
+            },
+            daysOfWeek: {
+              type: "array",
+              items: {
+                type: "number",
+                minimum: 0,
+                maximum: 6
+              }
+            }
+          },
+          required: ["label", "startLocal", "endLocal"]
+        }
+      }
+    }
+  ],
+  examples: [
+    [
+      { name: "{{name1}}", content: { text: "What's on my calendar today?" } },
+      {
+        name: "{{agentName}}",
+        content: {
+          text: "Events today:\n- **Team sync** (10:00 AM \u2013 10:30 AM)"
+        }
+      }
+    ],
+    [
+      {
+        name: "{{name1}}",
+        content: { text: "Create a dentist appointment for tomorrow at 3pm." }
+      },
+      {
+        name: "{{agentName}}",
+        content: {
+          text: 'Created calendar event "Dentist appointment" for tomorrow at 3:00 PM.'
+        }
+      }
+    ],
+    [
+      {
+        name: "{{name1}}",
+        content: { text: "Am I free tomorrow between 2pm and 4pm?" }
+      },
+      {
+        name: "{{agentName}}",
+        content: {
+          text: "You're free from Tue, Apr 20, 2:00 PM to Tue, Apr 20, 4:00 PM."
+        }
+      }
+    ],
+    [
+      {
+        name: "{{name1}}",
+        content: {
+          text: "Propose three 30-minute slots for a sync with a colleague next week."
+        }
+      },
+      {
+        name: "{{agentName}}",
+        content: {
+          text: "Here are 3 options you can offer:\n1. Mon, Apr 27, 10:00 AM \u2013 10:30 AM (30 min)\n2. Tue, Apr 28, 2:00 PM \u2013 2:30 PM (30 min)\n3. Wed, Apr 29, 11:00 AM \u2013 11:30 AM (30 min)"
+        }
+      }
+    ],
+    [
+      {
+        name: "{{name1}}",
+        content: {
+          text: "No calls between 11pm and 8am unless I explicitly say it's okay."
+        }
+      },
+      {
+        name: "{{agentName}}",
+        content: {
+          text: "Updated your meeting preferences to block calls from 11:00 PM to 8:00 AM unless you override it."
+        }
+      }
+    ],
+    [
+      {
+        name: "{{name1}}",
+        content: {
+          text: "Need to book 1 hour per day for a recurring 1:1 with my partner. Any time is fine, ideally before sleep."
+        }
+      },
+      {
+        name: "{{agentName}}",
+        content: {
+          text: "I'll set up a recurring daily one-hour block and keep it biased toward the evening before your sleep window."
+        }
+      }
+    ],
+    [
+      {
+        name: "{{name1}}",
+        content: {
+          text: "I'm in Tokyo for limited time so let's schedule PendingReality and Ryan at the same time if possible."
+        }
+      },
+      {
+        name: "{{agentName}}",
+        content: {
+          text: "I'll look for Tokyo-time options that bundle PendingReality and Ryan into the same window and flag the best slots."
+        }
+      }
+    ],
+    [
+      {
+        name: "{{name1}}",
+        content: {
+          text: "Flag the conflict before my flight later and, if needed, help rebook the other thing."
+        }
+      },
+      {
+        name: "{{agentName}}",
+        content: {
+          text: "I'll check the flight conflict, surface the conflicting event, and hold any rebooking behind your approval."
+        }
+      }
+    ],
+    [
+      {
+        name: "{{name1}}",
+        content: {
+          text: "We're gonna cancel some stuff and push everything back until next month. All partnership meetings."
+        }
+      },
+      {
+        name: "{{agentName}}",
+        content: {
+          text: "I'll scope the partnership meetings affected and queue the bulk reschedule for your approval before anything is sent."
+        }
+      }
+    ]
+  ]
+};
+export {
+  calendarAction,
+  extractCalendarPlanWithLlm
+};
+//# sourceMappingURL=calendar.js.map