@elizaos/plugin-scheduling 2.0.0-alpha.1

package/dist/index.js

@@ -0,0 +1,1732 @@
+// src/services/scheduling-service.ts
+import { Service, logger } from "@elizaos/core";
+import { v4 as uuidv42 } from "uuid";
+
+// src/types.ts
+var DEFAULT_CONFIG = {
+  defaultReminderMinutes: [1440, 120],
+  // 24 hours, 2 hours
+  maxProposals: 3,
+  defaultMaxDaysOut: 7,
+  minMeetingDuration: 30,
+  defaultMeetingDuration: 60,
+  autoSendCalendarInvites: true,
+  autoScheduleReminders: true
+};
+
+// src/utils/ical.ts
+var escapeIcs = (str) => {
+  return str.replace(/\\/g, "\\\\").replace(/;/g, "\\;").replace(/,/g, "\\,").replace(/\n/g, "\\n");
+};
+var formatIcsDate = (isoString) => {
+  return isoString.replace(/[-:]/g, "").replace(/\.\d{3}/, "");
+};
+var icsRole = (role) => {
+  switch (role) {
+    case "organizer":
+      return "REQ-PARTICIPANT";
+    case "required":
+      return "REQ-PARTICIPANT";
+    case "optional":
+      return "OPT-PARTICIPANT";
+    default:
+      return "REQ-PARTICIPANT";
+  }
+};
+var foldLine = (line) => {
+  const maxLength = 75;
+  if (line.length <= maxLength) {
+    return line;
+  }
+  const lines = [];
+  let remaining = line;
+  while (remaining.length > 0) {
+    if (lines.length === 0) {
+      lines.push(remaining.slice(0, maxLength));
+      remaining = remaining.slice(maxLength);
+    } else {
+      lines.push(" " + remaining.slice(0, maxLength - 1));
+      remaining = remaining.slice(maxLength - 1);
+    }
+  }
+  return lines.join("\r\n");
+};
+var generateIcs = (event) => {
+  const lines = [];
+  lines.push("BEGIN:VCALENDAR");
+  lines.push("VERSION:2.0");
+  lines.push("PRODID:-//ElizaOS//SchedulingPlugin//EN");
+  lines.push("CALSCALE:GREGORIAN");
+  lines.push("METHOD:REQUEST");
+  lines.push("BEGIN:VEVENT");
+  lines.push(`UID:${event.uid}`);
+  lines.push(`DTSTAMP:${formatIcsDate((/* @__PURE__ */ new Date()).toISOString())}`);
+  lines.push(`DTSTART:${formatIcsDate(event.start)}`);
+  lines.push(`DTEND:${formatIcsDate(event.end)}`);
+  lines.push(`SUMMARY:${escapeIcs(event.title)}`);
+  if (event.description) {
+    lines.push(`DESCRIPTION:${escapeIcs(event.description)}`);
+  }
+  if (event.location) {
+    lines.push(`LOCATION:${escapeIcs(event.location)}`);
+  }
+  if (event.url) {
+    lines.push(`URL:${event.url}`);
+  }
+  if (event.organizer) {
+    lines.push(`ORGANIZER;CN=${escapeIcs(event.organizer.name)}:mailto:${event.organizer.email}`);
+  }
+  if (event.attendees) {
+    for (const attendee of event.attendees) {
+      const role = icsRole(attendee.role);
+      lines.push(
+        `ATTENDEE;ROLE=${role};PARTSTAT=NEEDS-ACTION;CN=${escapeIcs(attendee.name)}:mailto:${attendee.email}`
+      );
+    }
+  }
+  if (event.reminderMinutes) {
+    for (const minutes of event.reminderMinutes) {
+      lines.push("BEGIN:VALARM");
+      lines.push("ACTION:DISPLAY");
+      lines.push(`DESCRIPTION:${escapeIcs(event.title)}`);
+      lines.push(`TRIGGER:-PT${minutes}M`);
+      lines.push("END:VALARM");
+    }
+  }
+  lines.push("STATUS:CONFIRMED");
+  lines.push("SEQUENCE:0");
+  lines.push("END:VEVENT");
+  lines.push("END:VCALENDAR");
+  return lines.map(foldLine).join("\r\n");
+};
+var parseIcs = (ics) => {
+  const events = [];
+  const lines = ics.split(/\r?\n/);
+  let currentEvent = null;
+  let currentLine = "";
+  for (const line of lines) {
+    if (line.startsWith(" ") || line.startsWith("	")) {
+      currentLine += line.slice(1);
+      continue;
+    }
+    if (currentLine && currentEvent) {
+      processLine(currentLine, currentEvent);
+    }
+    currentLine = line;
+    if (line === "BEGIN:VEVENT") {
+      currentEvent = {};
+    } else if (line === "END:VEVENT" && currentEvent) {
+      if (currentEvent.uid && currentEvent.start && currentEvent.end && currentEvent.title) {
+        events.push(currentEvent);
+      }
+      currentEvent = null;
+    }
+  }
+  return events;
+};
+var processLine = (line, event) => {
+  const colonIndex = line.indexOf(":");
+  if (colonIndex === -1) return;
+  const keyPart = line.slice(0, colonIndex);
+  const value = line.slice(colonIndex + 1);
+  const semiIndex = keyPart.indexOf(";");
+  const key = semiIndex === -1 ? keyPart : keyPart.slice(0, semiIndex);
+  switch (key) {
+    case "UID":
+      event.uid = value;
+      break;
+    case "SUMMARY":
+      event.title = unescapeIcs(value);
+      break;
+    case "DESCRIPTION":
+      event.description = unescapeIcs(value);
+      break;
+    case "DTSTART":
+      event.start = parseIcsDate(value);
+      break;
+    case "DTEND":
+      event.end = parseIcsDate(value);
+      break;
+    case "LOCATION":
+      event.location = unescapeIcs(value);
+      break;
+    case "URL":
+      event.url = value;
+      break;
+  }
+};
+var unescapeIcs = (str) => {
+  return str.replace(/\\n/g, "\n").replace(/\\,/g, ",").replace(/\\;/g, ";").replace(/\\\\/g, "\\");
+};
+var parseIcsDate = (icsDate) => {
+  const match = /^(\d{4})(\d{2})(\d{2})T(\d{2})(\d{2})(\d{2})Z?$/.exec(icsDate);
+  if (match) {
+    const [, year, month, day, hour, minute, second] = match;
+    return `${year}-${month}-${day}T${hour}:${minute}:${second}Z`;
+  }
+  return icsDate;
+};
+
+// src/storage.ts
+import { v4 as uuidv4 } from "uuid";
+var SCHEDULING_AVAILABILITY = "scheduling_availability";
+var SCHEDULING_MEETING = "scheduling_meeting";
+var SCHEDULING_REMINDER = "scheduling_reminder";
+var SCHEDULING_REQUEST = "scheduling_request";
+var SCHEDULING_MEETING_INDEX_ROOM = "scheduling_meeting_index:room";
+var SCHEDULING_MEETING_INDEX_PARTICIPANT = "scheduling_meeting_index:participant";
+var SCHEDULING_REMINDER_INDEX_MEETING = "scheduling_reminder_index:meeting";
+async function getMeetingIndex(runtime, indexType, indexKey) {
+  const componentType = `${indexType}:${indexKey}`;
+  const component = await runtime.getComponent(runtime.agentId, componentType);
+  if (!component) {
+    return { meetingIds: [] };
+  }
+  return component.data;
+}
+async function saveMeetingIndex(runtime, indexType, indexKey, index) {
+  const componentType = `${indexType}:${indexKey}`;
+  const existing = await runtime.getComponent(runtime.agentId, componentType);
+  const component = {
+    id: existing?.id || uuidv4(),
+    entityId: runtime.agentId,
+    agentId: runtime.agentId,
+    roomId: uuidv4(),
+    worldId: existing?.worldId || uuidv4(),
+    sourceEntityId: runtime.agentId,
+    type: componentType,
+    createdAt: existing?.createdAt || Date.now(),
+    data: index
+  };
+  if (existing) {
+    await runtime.updateComponent(component);
+  } else {
+    await runtime.createComponent(component);
+  }
+}
+async function addToMeetingIndex(runtime, indexType, indexKey, meetingId) {
+  const index = await getMeetingIndex(runtime, indexType, indexKey);
+  if (!index.meetingIds.includes(meetingId)) {
+    index.meetingIds.push(meetingId);
+    await saveMeetingIndex(runtime, indexType, indexKey, index);
+  }
+}
+async function removeFromMeetingIndex(runtime, indexType, indexKey, meetingId) {
+  const index = await getMeetingIndex(runtime, indexType, indexKey);
+  index.meetingIds = index.meetingIds.filter((id) => id !== meetingId);
+  await saveMeetingIndex(runtime, indexType, indexKey, index);
+}
+async function getReminderIndex(runtime, meetingId) {
+  const componentType = `${SCHEDULING_REMINDER_INDEX_MEETING}:${meetingId}`;
+  const component = await runtime.getComponent(runtime.agentId, componentType);
+  return component ? component.data : { reminderIds: [] };
+}
+async function saveReminderIndex(runtime, meetingId, index) {
+  const componentType = `${SCHEDULING_REMINDER_INDEX_MEETING}:${meetingId}`;
+  const existing = await runtime.getComponent(runtime.agentId, componentType);
+  const component = {
+    id: existing?.id || uuidv4(),
+    entityId: runtime.agentId,
+    agentId: runtime.agentId,
+    roomId: uuidv4(),
+    worldId: existing?.worldId || uuidv4(),
+    sourceEntityId: runtime.agentId,
+    type: componentType,
+    createdAt: existing?.createdAt || Date.now(),
+    data: index
+  };
+  if (existing) {
+    await runtime.updateComponent(component);
+  } else {
+    await runtime.createComponent(component);
+  }
+}
+var getAvailabilityStorage = (runtime) => ({
+  get: async (entityId) => {
+    const componentType = `${SCHEDULING_AVAILABILITY}:${entityId}`;
+    const component = await runtime.getComponent(entityId, componentType);
+    if (!component) return null;
+    return component.data;
+  },
+  save: async (entityId, availability) => {
+    const componentType = `${SCHEDULING_AVAILABILITY}:${entityId}`;
+    const existing = await runtime.getComponent(entityId, componentType);
+    const component = {
+      id: existing?.id || uuidv4(),
+      entityId,
+      agentId: runtime.agentId,
+      roomId: uuidv4(),
+      worldId: existing?.worldId || uuidv4(),
+      sourceEntityId: runtime.agentId,
+      type: componentType,
+      createdAt: existing?.createdAt || Date.now(),
+      data: availability
+    };
+    if (existing) {
+      await runtime.updateComponent(component);
+    } else {
+      await runtime.createComponent(component);
+    }
+  },
+  delete: async (entityId) => {
+    const componentType = `${SCHEDULING_AVAILABILITY}:${entityId}`;
+    const existing = await runtime.getComponent(entityId, componentType);
+    if (existing) {
+      await runtime.deleteComponent(existing.id);
+    }
+  }
+});
+var getSchedulingRequestStorage = (runtime) => ({
+  get: async (requestId) => {
+    const componentType = `${SCHEDULING_REQUEST}:${requestId}`;
+    const component = await runtime.getComponent(runtime.agentId, componentType);
+    if (!component) return null;
+    return component.data;
+  },
+  save: async (request) => {
+    const componentType = `${SCHEDULING_REQUEST}:${request.id}`;
+    const existing = await runtime.getComponent(runtime.agentId, componentType);
+    const component = {
+      id: existing?.id || uuidv4(),
+      entityId: runtime.agentId,
+      agentId: runtime.agentId,
+      roomId: request.roomId,
+      worldId: existing?.worldId || uuidv4(),
+      sourceEntityId: runtime.agentId,
+      type: componentType,
+      createdAt: existing?.createdAt || Date.now(),
+      data: request
+    };
+    if (existing) {
+      await runtime.updateComponent(component);
+    } else {
+      await runtime.createComponent(component);
+    }
+  },
+  delete: async (requestId) => {
+    const componentType = `${SCHEDULING_REQUEST}:${requestId}`;
+    const existing = await runtime.getComponent(runtime.agentId, componentType);
+    if (existing) {
+      await runtime.deleteComponent(existing.id);
+    }
+  },
+  getByRoom: async (roomId) => {
+    const components = await runtime.getComponents(runtime.agentId);
+    const requests = [];
+    for (const component of components) {
+      if (component.type.startsWith(`${SCHEDULING_REQUEST}:`)) {
+        const request = component.data;
+        if (request.roomId === roomId) requests.push(request);
+      }
+    }
+    return requests;
+  }
+});
+var getMeetingStorage = (runtime) => ({
+  get: async (meetingId) => {
+    const componentType = `${SCHEDULING_MEETING}:${meetingId}`;
+    const component = await runtime.getComponent(runtime.agentId, componentType);
+    if (!component) return null;
+    return component.data;
+  },
+  save: async (meeting) => {
+    const componentType = `${SCHEDULING_MEETING}:${meeting.id}`;
+    const existing = await runtime.getComponent(runtime.agentId, componentType);
+    const component = {
+      id: existing?.id || uuidv4(),
+      entityId: runtime.agentId,
+      agentId: runtime.agentId,
+      roomId: meeting.roomId,
+      worldId: existing?.worldId || uuidv4(),
+      sourceEntityId: runtime.agentId,
+      type: componentType,
+      createdAt: existing?.createdAt || meeting.createdAt,
+      data: meeting
+    };
+    if (existing) {
+      await runtime.updateComponent(component);
+    } else {
+      await runtime.createComponent(component);
+      await addToMeetingIndex(runtime, SCHEDULING_MEETING_INDEX_ROOM, meeting.roomId, meeting.id);
+      for (const participant of meeting.participants) {
+        await addToMeetingIndex(
+          runtime,
+          SCHEDULING_MEETING_INDEX_PARTICIPANT,
+          participant.entityId,
+          meeting.id
+        );
+      }
+    }
+  },
+  delete: async (meetingId) => {
+    const componentType = `${SCHEDULING_MEETING}:${meetingId}`;
+    const existing = await runtime.getComponent(runtime.agentId, componentType);
+    if (existing) {
+      const meeting = existing.data;
+      await removeFromMeetingIndex(runtime, SCHEDULING_MEETING_INDEX_ROOM, meeting.roomId, meetingId);
+      for (const participant of meeting.participants) {
+        await removeFromMeetingIndex(
+          runtime,
+          SCHEDULING_MEETING_INDEX_PARTICIPANT,
+          participant.entityId,
+          meetingId
+        );
+      }
+      await runtime.deleteComponent(existing.id);
+    }
+  },
+  getByRoom: async (roomId) => {
+    const index = await getMeetingIndex(runtime, SCHEDULING_MEETING_INDEX_ROOM, roomId);
+    const meetings = [];
+    for (const meetingId of index.meetingIds) {
+      const componentType = `${SCHEDULING_MEETING}:${meetingId}`;
+      const component = await runtime.getComponent(runtime.agentId, componentType);
+      if (component) {
+        meetings.push(component.data);
+      }
+    }
+    return meetings;
+  },
+  getUpcomingForParticipant: async (entityId) => {
+    const index = await getMeetingIndex(runtime, SCHEDULING_MEETING_INDEX_PARTICIPANT, entityId);
+    const meetings = [];
+    const now = Date.now();
+    for (const meetingId of index.meetingIds) {
+      const componentType = `${SCHEDULING_MEETING}:${meetingId}`;
+      const component = await runtime.getComponent(runtime.agentId, componentType);
+      if (component) {
+        const meeting = component.data;
+        if (new Date(meeting.slot.start).getTime() > now && meeting.status !== "cancelled") {
+          meetings.push(meeting);
+        }
+      }
+    }
+    meetings.sort((a, b) => new Date(a.slot.start).getTime() - new Date(b.slot.start).getTime());
+    return meetings;
+  }
+});
+var REMINDER_REGISTRY = "scheduling_reminder_registry";
+async function getReminderRegistry(runtime) {
+  const component = await runtime.getComponent(runtime.agentId, REMINDER_REGISTRY);
+  if (!component) {
+    return { reminderIds: [] };
+  }
+  return component.data;
+}
+async function saveReminderRegistry(runtime, registry) {
+  const existing = await runtime.getComponent(runtime.agentId, REMINDER_REGISTRY);
+  const component = {
+    id: existing?.id || uuidv4(),
+    entityId: runtime.agentId,
+    agentId: runtime.agentId,
+    roomId: uuidv4(),
+    worldId: existing?.worldId || uuidv4(),
+    sourceEntityId: runtime.agentId,
+    type: REMINDER_REGISTRY,
+    createdAt: existing?.createdAt || Date.now(),
+    data: registry
+  };
+  if (existing) {
+    await runtime.updateComponent(component);
+  } else {
+    await runtime.createComponent(component);
+  }
+}
+var getReminderStorage = (runtime) => ({
+  get: async (reminderId) => {
+    const componentType = `${SCHEDULING_REMINDER}:${reminderId}`;
+    const component = await runtime.getComponent(runtime.agentId, componentType);
+    if (!component) return null;
+    return component.data;
+  },
+  save: async (reminder) => {
+    const componentType = `${SCHEDULING_REMINDER}:${reminder.id}`;
+    const existing = await runtime.getComponent(runtime.agentId, componentType);
+    const component = {
+      id: existing?.id || uuidv4(),
+      entityId: runtime.agentId,
+      agentId: runtime.agentId,
+      roomId: uuidv4(),
+      worldId: existing?.worldId || uuidv4(),
+      sourceEntityId: runtime.agentId,
+      type: componentType,
+      createdAt: existing?.createdAt || reminder.createdAt,
+      data: reminder
+    };
+    if (existing) {
+      await runtime.updateComponent(component);
+    } else {
+      await runtime.createComponent(component);
+      const index = await getReminderIndex(runtime, reminder.meetingId);
+      if (!index.reminderIds.includes(reminder.id)) {
+        index.reminderIds.push(reminder.id);
+        await saveReminderIndex(runtime, reminder.meetingId, index);
+      }
+      const registry = await getReminderRegistry(runtime);
+      if (!registry.reminderIds.includes(reminder.id)) {
+        registry.reminderIds.push(reminder.id);
+        await saveReminderRegistry(runtime, registry);
+      }
+    }
+  },
+  delete: async (reminderId) => {
+    const componentType = `${SCHEDULING_REMINDER}:${reminderId}`;
+    const existing = await runtime.getComponent(runtime.agentId, componentType);
+    if (existing) {
+      const reminder = existing.data;
+      const index = await getReminderIndex(runtime, reminder.meetingId);
+      index.reminderIds = index.reminderIds.filter((id) => id !== reminderId);
+      await saveReminderIndex(runtime, reminder.meetingId, index);
+      const registry = await getReminderRegistry(runtime);
+      registry.reminderIds = registry.reminderIds.filter((id) => id !== reminderId);
+      await saveReminderRegistry(runtime, registry);
+      await runtime.deleteComponent(existing.id);
+    }
+  },
+  getByMeeting: async (meetingId) => {
+    const index = await getReminderIndex(runtime, meetingId);
+    const reminders = [];
+    for (const reminderId of index.reminderIds) {
+      const componentType = `${SCHEDULING_REMINDER}:${reminderId}`;
+      const component = await runtime.getComponent(runtime.agentId, componentType);
+      if (component) {
+        reminders.push(component.data);
+      }
+    }
+    return reminders;
+  },
+  getDue: async () => {
+    const registry = await getReminderRegistry(runtime);
+    const now = Date.now();
+    const dueReminders = [];
+    for (const reminderId of registry.reminderIds) {
+      const componentType = `${SCHEDULING_REMINDER}:${reminderId}`;
+      const component = await runtime.getComponent(runtime.agentId, componentType);
+      if (component) {
+        const reminder = component.data;
+        if (reminder.status === "pending" && new Date(reminder.scheduledFor).getTime() <= now) {
+          dueReminders.push(reminder);
+        }
+      }
+    }
+    return dueReminders;
+  }
+});
+
+// src/services/scheduling-service.ts
+var DAY_INDEX = {
+  Mon: "mon",
+  Tue: "tue",
+  Wed: "wed",
+  Thu: "thu",
+  Fri: "fri",
+  Sat: "sat",
+  Sun: "sun"
+};
+var getZonedParts = (date, timeZone) => {
+  const formatter = new Intl.DateTimeFormat("en-US", {
+    timeZone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    weekday: "short",
+    hour: "2-digit",
+    minute: "2-digit",
+    hour12: false
+  });
+  const parts = formatter.formatToParts(date);
+  const out = {};
+  for (const part of parts) {
+    if (part.type !== "literal") {
+      out[part.type] = part.value;
+    }
+  }
+  return out;
+};
+var getDayOfWeek = (date, timeZone) => {
+  const parts = getZonedParts(date, timeZone);
+  return DAY_INDEX[parts.weekday] ?? "mon";
+};
+var getMinutesOfDay = (date, timeZone) => {
+  const parts = getZonedParts(date, timeZone);
+  return Number(parts.hour) * 60 + Number(parts.minute);
+};
+var getDateString = (date, timeZone) => {
+  const parts = getZonedParts(date, timeZone);
+  return `${parts.year}-${parts.month}-${parts.day}`;
+};
+var dateFromMinutes = (dateStr, minutes, timeZone) => {
+  const [year, month, day] = dateStr.split("-").map(Number);
+  const hours = Math.floor(minutes / 60);
+  const mins = minutes % 60;
+  const localDateStr = `${year}-${String(month).padStart(2, "0")}-${String(day).padStart(2, "0")}T${String(hours).padStart(2, "0")}:${String(mins).padStart(2, "0")}:00`;
+  const formatter = new Intl.DateTimeFormat("en-US", {
+    timeZone,
+    timeZoneName: "longOffset"
+  });
+  const tempDate = /* @__PURE__ */ new Date(localDateStr + "Z");
+  const offsetParts = formatter.formatToParts(tempDate);
+  const offsetPart = offsetParts.find((p) => p.type === "timeZoneName");
+  let offsetMinutes = 0;
+  if (offsetPart) {
+    const match = /GMT([+-])(\d{2}):(\d{2})/.exec(offsetPart.value);
+    if (match) {
+      const sign = match[1] === "+" ? 1 : -1;
+      offsetMinutes = sign * (Number(match[2]) * 60 + Number(match[3]));
+    }
+  }
+  const utcMs = Date.UTC(year, month - 1, day, hours, mins, 0, 0) - offsetMinutes * 60 * 1e3;
+  return new Date(utcMs);
+};
+var addDays = (date, days) => {
+  const result = new Date(date);
+  result.setDate(result.getDate() + days);
+  return result;
+};
+var SchedulingService = class _SchedulingService extends Service {
+  static serviceType = "SCHEDULING";
+  capabilityDescription = "Coordinates scheduling and calendar management across multiple participants";
+  schedulingConfig;
+  constructor(runtime, schedulingConfig) {
+    super(runtime);
+    this.schedulingConfig = { ...DEFAULT_CONFIG, ...schedulingConfig };
+  }
+  static async start(runtime) {
+    const service = new _SchedulingService(runtime);
+    const healthStatus = await service.healthCheck();
+    if (!healthStatus.healthy) {
+      logger.warn(`[SchedulingService] Started with warnings: ${healthStatus.issues.join(", ")}`);
+    } else {
+      logger.info(`[SchedulingService] Started for agent ${runtime.agentId}`);
+    }
+    return service;
+  }
+  async stop() {
+    logger.info("[SchedulingService] Stopped");
+  }
+  async healthCheck() {
+    const issues = [];
+    if (!this.runtime.getComponent) {
+      issues.push("Runtime missing getComponent method");
+    }
+    if (!this.runtime.createComponent) {
+      issues.push("Runtime missing createComponent method");
+    }
+    const emailService = this.runtime.getService("EMAIL");
+    if (!emailService) {
+      issues.push("EMAIL service not available");
+    }
+    return { healthy: issues.length === 0, issues };
+  }
+  getSchedulingConfig() {
+    return { ...this.schedulingConfig };
+  }
+  async saveAvailability(entityId, availability) {
+    const storage = getAvailabilityStorage(this.runtime);
+    await storage.save(entityId, availability);
+  }
+  async getAvailability(entityId) {
+    return getAvailabilityStorage(this.runtime).get(entityId);
+  }
+  isAvailableAt(availability, dateTime) {
+    const day = getDayOfWeek(dateTime, availability.timeZone);
+    const minutes = getMinutesOfDay(dateTime, availability.timeZone);
+    const dateStr = getDateString(dateTime, availability.timeZone);
+    const exception = availability.exceptions.find((e) => e.date === dateStr);
+    if (exception) {
+      if (exception.unavailable) return false;
+      if (exception.startMinutes !== void 0 && exception.endMinutes !== void 0) {
+        return minutes >= exception.startMinutes && minutes < exception.endMinutes;
+      }
+    }
+    return availability.weekly.some(
+      (window) => window.day === day && minutes >= window.startMinutes && minutes < window.endMinutes
+    );
+  }
+  async createSchedulingRequest(roomId, title, participants, constraints = {}, options) {
+    const request = {
+      id: uuidv42(),
+      roomId,
+      title,
+      description: options?.description,
+      participants,
+      constraints: {
+        minDurationMinutes: constraints.minDurationMinutes ?? this.schedulingConfig.minMeetingDuration,
+        preferredDurationMinutes: constraints.preferredDurationMinutes ?? this.schedulingConfig.defaultMeetingDuration,
+        maxDaysOut: constraints.maxDaysOut ?? this.schedulingConfig.defaultMaxDaysOut,
+        preferredTimes: constraints.preferredTimes,
+        preferredDays: constraints.preferredDays,
+        locationType: constraints.locationType,
+        locationConstraint: constraints.locationConstraint
+      },
+      urgency: options?.urgency ?? "flexible",
+      createdAt: Date.now(),
+      maxProposals: this.schedulingConfig.maxProposals
+    };
+    const storage = getSchedulingRequestStorage(this.runtime);
+    await storage.save(request);
+    logger.info(`[SchedulingService] Created scheduling request ${request.id} for "${title}"`);
+    return request;
+  }
+  async findAvailableSlots(request) {
+    const { participants, constraints } = request;
+    if (participants.length === 0) {
+      return {
+        success: false,
+        proposedSlots: [],
+        failureReason: "No participants specified"
+      };
+    }
+    const availabilities = participants.map((p) => ({
+      participant: p,
+      availability: p.availability
+    }));
+    const referenceTimeZone = availabilities[0].availability.timeZone;
+    const now = /* @__PURE__ */ new Date();
+    const candidateSlots = [];
+    for (let dayOffset = 0; dayOffset < constraints.maxDaysOut; dayOffset++) {
+      const date = addDays(now, dayOffset);
+      const day = getDayOfWeek(date, referenceTimeZone);
+      if (constraints.preferredDays && !constraints.preferredDays.includes(day)) {
+        continue;
+      }
+      const dateStr = getDateString(date, referenceTimeZone);
+      const dayWindows = this.findDayIntersection(availabilities, day, dateStr, constraints.minDurationMinutes);
+      for (const window of dayWindows) {
+        const slotDuration = constraints.preferredDurationMinutes;
+        let startMinutes = window.start;
+        while (startMinutes + slotDuration <= window.end) {
+          if (dayOffset === 0) {
+            const currentMinutes = getMinutesOfDay(now, referenceTimeZone);
+            if (startMinutes < currentMinutes + 30) {
+              startMinutes += 30;
+              continue;
+            }
+          }
+          const startDate = dateFromMinutes(dateStr, startMinutes, referenceTimeZone);
+          const endDate = dateFromMinutes(dateStr, startMinutes + slotDuration, referenceTimeZone);
+          candidateSlots.push({
+            start: startDate.toISOString(),
+            end: endDate.toISOString(),
+            timeZone: referenceTimeZone
+          });
+          startMinutes += 30;
+        }
+      }
+    }
+    if (candidateSlots.length === 0) {
+      const conflicting = this.findConflictingParticipants(availabilities);
+      return {
+        success: false,
+        proposedSlots: [],
+        failureReason: "No available time slots found within constraints",
+        conflictingParticipants: conflicting
+      };
+    }
+    const scoredSlots = candidateSlots.map((slot) => this.scoreSlot(slot, request));
+    scoredSlots.sort((a, b) => b.score - a.score);
+    const proposedSlots = scoredSlots.slice(0, 3);
+    return {
+      success: true,
+      proposedSlots
+    };
+  }
+  findDayIntersection(availabilities, day, dateStr, minDuration) {
+    const participantWindows = availabilities.map(({ availability }) => {
+      const exception = availability.exceptions.find((e) => e.date === dateStr);
+      if (exception?.unavailable) {
+        return [];
+      }
+      if (exception?.startMinutes !== void 0 && exception?.endMinutes !== void 0) {
+        return [{ start: exception.startMinutes, end: exception.endMinutes }];
+      }
+      return availability.weekly.filter((w) => w.day === day).map((w) => ({ start: w.startMinutes, end: w.endMinutes }));
+    });
+    if (participantWindows.some((windows) => windows.length === 0)) {
+      return [];
+    }
+    let intersection = participantWindows[0];
+    for (let i = 1; i < participantWindows.length; i++) {
+      const newIntersection = [];
+      for (const windowA of intersection) {
+        for (const windowB of participantWindows[i]) {
+          const start = Math.max(windowA.start, windowB.start);
+          const end = Math.min(windowA.end, windowB.end);
+          if (end - start >= minDuration) {
+            newIntersection.push({ start, end });
+          }
+        }
+      }
+      intersection = newIntersection;
+      if (intersection.length === 0) break;
+    }
+    return intersection;
+  }
+  findConflictingParticipants(availabilities) {
+    const conflicting = [];
+    for (let i = 0; i < availabilities.length; i++) {
+      let hasOverlapWithAll = true;
+      for (let j = 0; j < availabilities.length; j++) {
+        if (i === j) continue;
+        const hasOverlap = this.hasAnyOverlap(
+          availabilities[i].availability,
+          availabilities[j].availability
+        );
+        if (!hasOverlap) {
+          hasOverlapWithAll = false;
+          break;
+        }
+      }
+      if (!hasOverlapWithAll) {
+        conflicting.push(availabilities[i].participant.entityId);
+      }
+    }
+    return conflicting;
+  }
+  hasAnyOverlap(a, b) {
+    for (const windowA of a.weekly) {
+      for (const windowB of b.weekly) {
+        if (windowA.day !== windowB.day) continue;
+        const overlapStart = Math.max(windowA.startMinutes, windowB.startMinutes);
+        const overlapEnd = Math.min(windowA.endMinutes, windowB.endMinutes);
+        if (overlapEnd - overlapStart >= 30) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  scoreSlot(slot, request) {
+    const { constraints, urgency } = request;
+    let score = 100;
+    const reasons = [];
+    const concerns = [];
+    const startDate = new Date(slot.start);
+    const minutes = getMinutesOfDay(startDate, slot.timeZone);
+    const day = getDayOfWeek(startDate, slot.timeZone);
+    const timeOfDay = minutes < 12 * 60 ? "morning" : minutes < 17 * 60 ? "afternoon" : "evening";
+    if (constraints.preferredTimes?.includes(timeOfDay)) {
+      score += 20;
+      reasons.push(`Preferred time (${timeOfDay})`);
+    }
+    if (constraints.preferredDays?.includes(day)) {
+      score += 15;
+      reasons.push(`Preferred day (${day})`);
+    }
+    const daysFromNow = (startDate.getTime() - Date.now()) / (1e3 * 60 * 60 * 24);
+    if (urgency === "urgent") {
+      score -= daysFromNow * 10;
+      if (daysFromNow < 2) {
+        reasons.push("Soon (urgent meeting)");
+      }
+    } else if (urgency === "soon") {
+      score -= daysFromNow * 5;
+    }
+    if (minutes < 9 * 60) {
+      score -= 15;
+      concerns.push("Early morning");
+    } else if (minutes > 18 * 60) {
+      score -= 10;
+      concerns.push("Evening time");
+    }
+    if (minutes >= 10 * 60 && minutes <= 16 * 60) {
+      score += 10;
+      reasons.push("Standard business hours");
+    }
+    return {
+      slot,
+      score: Math.max(0, score),
+      reasons,
+      concerns
+    };
+  }
+  async createMeeting(request, slot, location) {
+    const participants = request.participants.map((p, index) => ({
+      entityId: p.entityId,
+      name: p.name,
+      email: p.email,
+      phone: p.phone,
+      role: index === 0 ? "organizer" : "required",
+      confirmed: false
+    }));
+    const meeting = {
+      id: uuidv42(),
+      requestId: request.id,
+      roomId: request.roomId,
+      title: request.title,
+      description: request.description,
+      slot,
+      location: {
+        type: location.type,
+        name: location.name,
+        address: location.address,
+        city: location.city,
+        videoUrl: location.videoUrl,
+        phoneNumber: location.phoneNumber,
+        notes: location.notes
+      },
+      participants,
+      status: "proposed",
+      rescheduleCount: 0,
+      createdAt: Date.now(),
+      updatedAt: Date.now()
+    };
+    const storage = getMeetingStorage(this.runtime);
+    await storage.save(meeting);
+    logger.info(`[SchedulingService] Created meeting ${meeting.id} for "${meeting.title}"`);
+    if (this.schedulingConfig.autoScheduleReminders) {
+      await this.scheduleReminders(meeting);
+    }
+    return meeting;
+  }
+  async getMeeting(meetingId) {
+    return getMeetingStorage(this.runtime).get(meetingId);
+  }
+  async getMeetingsForRoom(roomId) {
+    return getMeetingStorage(this.runtime).getByRoom(roomId);
+  }
+  async getUpcomingMeetings(entityId) {
+    return getMeetingStorage(this.runtime).getUpcomingForParticipant(entityId);
+  }
+  async confirmParticipant(meetingId, entityId) {
+    const meeting = await this.getMeeting(meetingId);
+    if (!meeting) {
+      throw new Error(`Meeting not found: ${meetingId}`);
+    }
+    const participant = meeting.participants.find((p) => p.entityId === entityId);
+    if (!participant) {
+      throw new Error(`Participant not found in meeting: ${entityId}`);
+    }
+    participant.confirmed = true;
+    participant.confirmedAt = Date.now();
+    meeting.updatedAt = Date.now();
+    const allConfirmed = meeting.participants.filter((p) => p.role !== "optional").every((p) => p.confirmed);
+    if (allConfirmed && meeting.status === "proposed") {
+      meeting.status = "confirmed";
+      logger.info(`[SchedulingService] Meeting ${meetingId} confirmed by all participants`);
+      if (this.schedulingConfig.autoSendCalendarInvites) {
+        await this.sendCalendarInvites(meeting);
+        meeting.status = "scheduled";
+      }
+    }
+    const storage = getMeetingStorage(this.runtime);
+    await storage.save(meeting);
+    return meeting;
+  }
+  async declineParticipant(meetingId, entityId, reason) {
+    const meeting = await this.getMeeting(meetingId);
+    if (!meeting) {
+      throw new Error(`Meeting not found: ${meetingId}`);
+    }
+    const participant = meeting.participants.find((p) => p.entityId === entityId);
+    if (!participant) {
+      throw new Error(`Participant not found in meeting: ${entityId}`);
+    }
+    participant.confirmed = false;
+    participant.declineReason = reason;
+    meeting.updatedAt = Date.now();
+    if (participant.role !== "optional") {
+      meeting.status = "rescheduling";
+      meeting.cancellationReason = `${participant.name} declined: ${reason || "No reason given"}`;
+      logger.info(`[SchedulingService] Meeting ${meetingId} needs rescheduling`);
+    }
+    const storage = getMeetingStorage(this.runtime);
+    await storage.save(meeting);
+    return meeting;
+  }
+  async cancelMeeting(meetingId, reason) {
+    const meeting = await this.getMeeting(meetingId);
+    if (!meeting) {
+      throw new Error(`Meeting not found: ${meetingId}`);
+    }
+    meeting.status = "cancelled";
+    meeting.cancellationReason = reason;
+    meeting.updatedAt = Date.now();
+    await this.cancelReminders(meetingId);
+    const storage = getMeetingStorage(this.runtime);
+    await storage.save(meeting);
+    logger.info(`[SchedulingService] Meeting ${meetingId} cancelled`);
+    return meeting;
+  }
+  async updateMeetingStatus(meetingId, status) {
+    const meeting = await this.getMeeting(meetingId);
+    if (!meeting) {
+      throw new Error(`Meeting not found: ${meetingId}`);
+    }
+    meeting.status = status;
+    meeting.updatedAt = Date.now();
+    const storage = getMeetingStorage(this.runtime);
+    await storage.save(meeting);
+    return meeting;
+  }
+  async rescheduleMeeting(meetingId, newSlot, reason) {
+    const meeting = await this.getMeeting(meetingId);
+    if (!meeting) {
+      throw new Error(`Meeting not found: ${meetingId}`);
+    }
+    await this.cancelReminders(meetingId);
+    meeting.slot = newSlot;
+    meeting.status = "proposed";
+    meeting.rescheduleCount += 1;
+    meeting.cancellationReason = reason;
+    meeting.updatedAt = Date.now();
+    for (const participant of meeting.participants) {
+      participant.confirmed = false;
+      participant.confirmedAt = void 0;
+    }
+    const storage = getMeetingStorage(this.runtime);
+    await storage.save(meeting);
+    if (this.schedulingConfig.autoScheduleReminders) {
+      await this.scheduleReminders(meeting);
+    }
+    logger.info(`[SchedulingService] Meeting ${meetingId} rescheduled (count: ${meeting.rescheduleCount})`);
+    return meeting;
+  }
+  generateCalendarInvite(meeting, recipientEmail, recipientName) {
+    const organizer = meeting.participants.find((p) => p.role === "organizer");
+    const event = {
+      uid: meeting.id,
+      title: meeting.title,
+      description: meeting.description,
+      start: meeting.slot.start,
+      end: meeting.slot.end,
+      timeZone: meeting.slot.timeZone,
+      location: meeting.location.type === "in_person" ? `${meeting.location.name}, ${meeting.location.address}` : meeting.location.videoUrl,
+      organizer: organizer?.email ? { name: organizer.name, email: organizer.email } : void 0,
+      attendees: meeting.participants.filter((p) => p.email).map((p) => ({
+        name: p.name,
+        email: p.email,
+        role: p.role
+      })),
+      url: meeting.location.videoUrl,
+      reminderMinutes: this.schedulingConfig.defaultReminderMinutes
+    };
+    const ics = generateIcs(event);
+    return {
+      ics,
+      event,
+      recipientEmail,
+      recipientName
+    };
+  }
+  /** Sends invites via EMAIL service if available, otherwise returns ICS for manual handling */
+  async sendCalendarInvites(meeting) {
+    const invites = [];
+    for (const participant of meeting.participants) {
+      if (!participant.email) {
+        logger.warn(
+          `[SchedulingService] Participant ${participant.name} has no email - skipping calendar invite`
+        );
+        continue;
+      }
+      const invite = this.generateCalendarInvite(meeting, participant.email, participant.name);
+      invites.push(invite);
+      const emailService = this.runtime.getService("EMAIL");
+      const emailServiceAny = emailService;
+      if (emailService && typeof emailServiceAny.sendEmail === "function") {
+        try {
+          await emailServiceAny.sendEmail(
+            participant.email,
+            `Meeting Invite: ${meeting.title}`,
+            this.formatInviteEmail(meeting, participant.name),
+            [{
+              filename: "invite.ics",
+              content: invite.ics,
+              contentType: "text/calendar"
+            }]
+          );
+          logger.info(
+            `[SchedulingService] Sent calendar invite to ${participant.email} for meeting ${meeting.id}`
+          );
+        } catch (err) {
+          logger.error(
+            `[SchedulingService] Failed to send email to ${participant.email} for meeting ${meeting.id}: ${err}`
+          );
+        }
+      } else {
+        logger.warn(
+          `[SchedulingService] No EMAIL service available - calendar invite for ${participant.email} generated but not sent. ICS content available in returned invite object.`
+        );
+      }
+    }
+    return invites;
+  }
+  formatInviteEmail(meeting, recipientName) {
+    const startDate = new Date(meeting.slot.start);
+    const endDate = new Date(meeting.slot.end);
+    const dateFormatter = new Intl.DateTimeFormat("en-US", {
+      timeZone: meeting.slot.timeZone,
+      weekday: "long",
+      year: "numeric",
+      month: "long",
+      day: "numeric"
+    });
+    const timeFormatter = new Intl.DateTimeFormat("en-US", {
+      timeZone: meeting.slot.timeZone,
+      hour: "numeric",
+      minute: "2-digit",
+      timeZoneName: "short"
+    });
+    let locationText = "";
+    if (meeting.location.type === "virtual" && meeting.location.videoUrl) {
+      locationText = `Join online: ${meeting.location.videoUrl}`;
+    } else if (meeting.location.type === "in_person") {
+      locationText = `Location: ${meeting.location.name}, ${meeting.location.address}`;
+    } else if (meeting.location.type === "phone" && meeting.location.phoneNumber) {
+      locationText = `Call: ${meeting.location.phoneNumber}`;
+    }
+    return `Hi ${recipientName},
+
+You're invited to: ${meeting.title}
+
+When: ${dateFormatter.format(startDate)}
+Time: ${timeFormatter.format(startDate)} - ${timeFormatter.format(endDate)}
+${locationText}
+
+${meeting.description || ""}
+
+Please add the attached calendar invite to your calendar.
+
+See you there!`;
+  }
+  async scheduleReminders(meeting) {
+    const reminders = [];
+    const meetingTime = new Date(meeting.slot.start).getTime();
+    for (const minutesBefore of this.schedulingConfig.defaultReminderMinutes) {
+      const scheduledFor = new Date(meetingTime - minutesBefore * 60 * 1e3);
+      if (scheduledFor.getTime() < Date.now()) continue;
+      for (const participant of meeting.participants) {
+        const type = participant.phone ? "sms" : participant.email ? "email" : "push";
+        const timeLabel = minutesBefore >= 1440 ? `${Math.round(minutesBefore / 1440)} day(s)` : minutesBefore >= 60 ? `${Math.round(minutesBefore / 60)} hour(s)` : `${minutesBefore} minutes`;
+        const reminder = {
+          id: uuidv42(),
+          meetingId: meeting.id,
+          participantId: participant.entityId,
+          scheduledFor: scheduledFor.toISOString(),
+          type,
+          message: `Reminder: "${meeting.title}" is in ${timeLabel}`,
+          status: "pending",
+          createdAt: Date.now()
+        };
+        reminders.push(reminder);
+      }
+    }
+    const storage = getReminderStorage(this.runtime);
+    for (const reminder of reminders) {
+      await storage.save(reminder);
+    }
+    logger.debug(`[SchedulingService] Scheduled ${reminders.length} reminders for meeting ${meeting.id}`);
+    return reminders;
+  }
+  async getDueReminders() {
+    return getReminderStorage(this.runtime).getDue();
+  }
+  async markReminderSent(reminderId) {
+    const storage = getReminderStorage(this.runtime);
+    const reminder = await storage.get(reminderId);
+    if (!reminder) return;
+    reminder.status = "sent";
+    reminder.sentAt = Date.now();
+    await storage.save(reminder);
+  }
+  async cancelReminders(meetingId) {
+    const storage = getReminderStorage(this.runtime);
+    const reminders = await storage.getByMeeting(meetingId);
+    for (const reminder of reminders) {
+      if (reminder.status === "pending") {
+        reminder.status = "cancelled";
+        await storage.save(reminder);
+      }
+    }
+  }
+  formatSlot(slot, locale = "en-US") {
+    const start = new Date(slot.start);
+    const end = new Date(slot.end);
+    const dateFormatter = new Intl.DateTimeFormat(locale, {
+      timeZone: slot.timeZone,
+      weekday: "short",
+      month: "short",
+      day: "numeric"
+    });
+    const timeFormatter = new Intl.DateTimeFormat(locale, {
+      timeZone: slot.timeZone,
+      hour: "numeric",
+      minute: "2-digit"
+    });
+    return `${dateFormatter.format(start)}, ${timeFormatter.format(start)} - ${timeFormatter.format(end)}`;
+  }
+  getConfig() {
+    return { ...this.schedulingConfig };
+  }
+};
+
+// src/actions/schedule-meeting.ts
+var parseMeetingRequest = (text) => {
+  const normalized = text.toLowerCase();
+  const result = {};
+  const titleMatch = /(?:schedule|book|arrange|set up|plan)\s+(?:a\s+)?(?:meeting|call|chat)\s+(?:about|for|regarding|to discuss)\s+["']?([^"'\n.]+)["']?/i.exec(
+    text
+  );
+  if (titleMatch) {
+    result.title = titleMatch[1].trim();
+  }
+  const durationMatch = /(\d+)\s*(?:minute|min|hour|hr)/i.exec(normalized);
+  if (durationMatch) {
+    let duration = Number.parseInt(durationMatch[1], 10);
+    if (normalized.includes("hour") || normalized.includes("hr")) {
+      duration *= 60;
+    }
+    result.duration = duration;
+  }
+  if (normalized.includes("urgent") || normalized.includes("asap") || normalized.includes("immediately")) {
+    result.urgency = "urgent";
+  } else if (normalized.includes("soon") || normalized.includes("this week")) {
+    result.urgency = "soon";
+  } else {
+    result.urgency = "flexible";
+  }
+  return result;
+};
+var formatProposedSlots = (slots) => {
+  if (slots.length === 0) {
+    return "I couldn't find any available time slots.";
+  }
+  const options = {
+    weekday: "short",
+    month: "short",
+    day: "numeric",
+    hour: "numeric",
+    minute: "2-digit"
+  };
+  const formatted = slots.map((proposal, index) => {
+    const start = new Date(proposal.slot.start);
+    const end = new Date(proposal.slot.end);
+    const formatter = new Intl.DateTimeFormat("en-US", {
+      ...options,
+      timeZone: proposal.slot.timeZone
+    });
+    const timeFormatter = new Intl.DateTimeFormat("en-US", {
+      hour: "numeric",
+      minute: "2-digit",
+      timeZone: proposal.slot.timeZone
+    });
+    const dateStr = formatter.format(start);
+    const endTimeStr = timeFormatter.format(end);
+    let entry = `${index + 1}. ${dateStr} - ${endTimeStr}`;
+    if (proposal.reasons.length > 0) {
+      entry += ` (${proposal.reasons[0]})`;
+    }
+    return entry;
+  });
+  return `Here are some times that work:
+
+${formatted.join("\n")}
+
+Which option works best for you? Just say the number.`;
+};
+var scheduleMeetingAction = {
+  name: "SCHEDULE_MEETING",
+  similes: [
+    "BOOK_MEETING",
+    "ARRANGE_MEETING",
+    "SET_UP_MEETING",
+    "PLAN_MEETING",
+    "CREATE_MEETING"
+  ],
+  description: "Schedule a meeting between multiple participants by finding a suitable time slot",
+  validate: async (_runtime, message) => {
+    const text = message.content?.text?.toLowerCase() ?? "";
+    return text.includes("schedule") || text.includes("book") || text.includes("arrange") || text.includes("set up") || text.includes("plan") || text.includes("meet") && !text.includes("nice to meet");
+  },
+  handler: async (runtime, message, _state, _options, callback) => {
+    const schedulingService = runtime.getService("SCHEDULING");
+    if (!schedulingService) {
+      await callback?.({
+        text: "Scheduling service is not available. Please try again later."
+      });
+      return { success: false };
+    }
+    const entityId = message.entityId;
+    const roomId = message.roomId;
+    if (!entityId || !roomId) {
+      await callback?.({
+        text: "I could not identify the conversation context. Please try again."
+      });
+      return { success: false };
+    }
+    const text = message.content?.text ?? "";
+    const parsed = parseMeetingRequest(text);
+    const userAvailability = await schedulingService.getAvailability(entityId);
+    if (!userAvailability || userAvailability.weekly.length === 0) {
+      await callback?.({
+        text: `I don't have your availability yet. Tell me when you're free, e.g. "weekdays 9am-5pm"`
+      });
+      return { success: false };
+    }
+    const participants = [
+      { entityId, name: "You", availability: userAvailability }
+    ];
+    const title = parsed.title || "Meeting";
+    const request = await schedulingService.createSchedulingRequest(
+      roomId,
+      title,
+      participants,
+      {
+        preferredDurationMinutes: parsed.duration || 30,
+        maxDaysOut: parsed.urgency === "urgent" ? 3 : parsed.urgency === "soon" ? 7 : 14
+      },
+      {
+        urgency: parsed.urgency
+      }
+    );
+    const result = await schedulingService.findAvailableSlots(request);
+    if (!result.success || result.proposedSlots.length === 0) {
+      await callback?.({ text: result.failureReason || "No available slots found. Try expanding your availability?" });
+      return { success: false };
+    }
+    await callback?.({ text: formatProposedSlots(result.proposedSlots) });
+    return {
+      success: true,
+      data: {
+        requestId: request.id,
+        proposedSlots: result.proposedSlots
+      }
+    };
+  },
+  examples: [
+    [
+      {
+        name: "{{user1}}",
+        content: { text: "Can you schedule a meeting for me?" }
+      },
+      {
+        name: "{{agentName}}",
+        content: {
+          text: "Here are some times that work:\n\n1. Mon, Jan 20 at 10:00am - 10:30am (Standard business hours)\n2. Mon, Jan 20 at 2:00pm - 2:30pm (Standard business hours)\n3. Tue, Jan 21 at 9:00am - 9:30am (Preferred time)\n\nWhich option works best for you? Just say the number."
+        }
+      }
+    ],
+    [
+      {
+        name: "{{user1}}",
+        content: { text: "I'd like to set up a call for next week" }
+      },
+      {
+        name: "{{agentName}}",
+        content: {
+          text: "Here are some times that work:\n\n1. Mon, Jan 20 at 10:00am - 10:30am (Standard business hours)\n2. Tue, Jan 21 at 2:00pm - 2:30pm (Preferred day)\n3. Wed, Jan 22 at 11:00am - 11:30am (Standard business hours)\n\nWhich option works best for you? Just say the number."
+        }
+      }
+    ]
+  ]
+};
+
+// src/actions/confirm-meeting.ts
+var confirmMeetingAction = {
+  name: "CONFIRM_MEETING",
+  similes: [
+    "ACCEPT_MEETING",
+    "CONFIRM_ATTENDANCE",
+    "RSVP_YES",
+    "DECLINE_MEETING",
+    "CANCEL_ATTENDANCE"
+  ],
+  description: "Confirm or decline attendance for a scheduled meeting",
+  validate: async (_runtime, message) => {
+    const text = message.content?.text?.toLowerCase() ?? "";
+    return text.includes("confirm") && text.includes("meeting") || text.includes("accept") && text.includes("meeting") || text.includes("decline") && text.includes("meeting") || text.includes("rsvp") || text.includes("i'll be there") || text.includes("i can't make it");
+  },
+  handler: async (runtime, message, _state, _options, callback) => {
+    const schedulingService = runtime.getService("SCHEDULING");
+    if (!schedulingService) {
+      await callback?.({
+        text: "Scheduling service is not available. Please try again later."
+      });
+      return { success: false };
+    }
+    const text = message.content?.text?.toLowerCase() ?? "";
+    const isConfirming = text.includes("confirm") || text.includes("accept") || text.includes("i'll be there") || text.includes("yes");
+    const meetings = await schedulingService.getUpcomingMeetings(message.entityId);
+    if (meetings.length === 0) {
+      await callback?.({
+        text: "You don't have any upcoming meetings to confirm."
+      });
+      return { success: false };
+    }
+    const pendingMeetings = meetings.filter((m) => m.status === "proposed");
+    if (pendingMeetings.length === 0) {
+      await callback?.({
+        text: "All your upcoming meetings have already been confirmed."
+      });
+      return { success: true };
+    }
+    const meeting = pendingMeetings[0];
+    if (isConfirming) {
+      await schedulingService.confirmParticipant(meeting.id, message.entityId);
+      const formattedTime = schedulingService.formatSlot(meeting.slot);
+      await callback?.({
+        text: `Great! I've confirmed your attendance for "${meeting.title}" on ${formattedTime}. You'll receive a calendar invite shortly.`
+      });
+    } else {
+      await schedulingService.declineParticipant(
+        meeting.id,
+        message.entityId,
+        "User declined via chat"
+      );
+      await callback?.({
+        text: `I've noted that you can't make it to "${meeting.title}". I'll let the other participants know and see if we can find another time.`
+      });
+    }
+    return { success: true };
+  },
+  examples: [
+    [
+      {
+        name: "{{user1}}",
+        content: { text: "Yes, I'll be there for the meeting" }
+      },
+      {
+        name: "{{agentName}}",
+        content: {
+          text: `Great! I've confirmed your attendance for "Coffee Chat" on Mon, Jan 20, 10:00 AM - 11:00 AM. You'll receive a calendar invite shortly.`
+        }
+      }
+    ],
+    [
+      {
+        name: "{{user1}}",
+        content: { text: "I can't make the meeting, something came up" }
+      },
+      {
+        name: "{{agentName}}",
+        content: {
+          text: `I've noted that you can't make it to "Coffee Chat". I'll let the other participants know and see if we can find another time.`
+        }
+      }
+    ]
+  ]
+};
+
+// src/actions/set-availability.ts
+var DAY_NAMES = {
+  monday: "mon",
+  mon: "mon",
+  tuesday: "tue",
+  tue: "tue",
+  wednesday: "wed",
+  wed: "wed",
+  thursday: "thu",
+  thu: "thu",
+  friday: "fri",
+  fri: "fri",
+  saturday: "sat",
+  sat: "sat",
+  sunday: "sun",
+  sun: "sun"
+};
+var TIME_PRESETS = {
+  morning: { start: 540, end: 720 },
+  afternoon: { start: 720, end: 1020 },
+  evening: { start: 1020, end: 1260 },
+  "business hours": { start: 540, end: 1020 },
+  "work hours": { start: 540, end: 1020 }
+};
+var parseTimeToMinutes = (timeStr) => {
+  const normalized = timeStr.toLowerCase().trim();
+  let match = /^(\d{1,2}):(\d{2})$/.exec(normalized);
+  if (match) {
+    const hours = Number.parseInt(match[1], 10);
+    const minutes = Number.parseInt(match[2], 10);
+    if (hours >= 0 && hours < 24 && minutes >= 0 && minutes < 60) {
+      return hours * 60 + minutes;
+    }
+  }
+  match = /^(\d{1,2})(?::(\d{2}))?\s*(am|pm)$/i.exec(normalized);
+  if (match) {
+    let hours = Number.parseInt(match[1], 10);
+    const minutes = match[2] ? Number.parseInt(match[2], 10) : 0;
+    const isPm = match[3].toLowerCase() === "pm";
+    if (hours === 12) {
+      hours = isPm ? 12 : 0;
+    } else if (isPm) {
+      hours += 12;
+    }
+    if (hours >= 0 && hours < 24 && minutes >= 0 && minutes < 60) {
+      return hours * 60 + minutes;
+    }
+  }
+  return null;
+};
+var parseDays = (dayStr) => {
+  const normalized = dayStr.toLowerCase().trim();
+  if (normalized === "weekday" || normalized === "weekdays") {
+    return ["mon", "tue", "wed", "thu", "fri"];
+  }
+  if (normalized === "weekend" || normalized === "weekends") {
+    return ["sat", "sun"];
+  }
+  if (normalized === "everyday" || normalized === "every day" || normalized === "daily") {
+    return ["mon", "tue", "wed", "thu", "fri", "sat", "sun"];
+  }
+  const day = DAY_NAMES[normalized];
+  return day ? [day] : [];
+};
+var parseAvailabilityText = (text) => {
+  const normalized = text.toLowerCase();
+  const windows = [];
+  let timeZone;
+  const tzMatch = /(?:time\s*zone|tz|timezone)[\s:]*([A-Za-z_\/]+)/i.exec(text) || /(America\/[A-Za-z_]+|Europe\/[A-Za-z_]+|Asia\/[A-Za-z_]+|Pacific\/[A-Za-z_]+|UTC)/i.exec(text);
+  if (tzMatch) {
+    timeZone = tzMatch[1];
+  }
+  const dayTimePattern = /(weekdays?|weekends?|monday|tuesday|wednesday|thursday|friday|saturday|sunday|mon|tue|wed|thu|fri|sat|sun|daily|every\s*day)(?:\s+(?:and\s+)?(?:weekdays?|weekends?|monday|tuesday|wednesday|thursday|friday|saturday|sunday|mon|tue|wed|thu|fri|sat|sun))*\s+(?:from\s+)?(\d{1,2}(?::\d{2})?\s*(?:am|pm)?)\s*(?:to|-)\s*(\d{1,2}(?::\d{2})?\s*(?:am|pm)?)/gi;
+  let match;
+  while ((match = dayTimePattern.exec(normalized)) !== null) {
+    const dayPart = match[1];
+    const startTime = match[2];
+    const endTime = match[3];
+    const days = parseDays(dayPart);
+    const startMinutes = parseTimeToMinutes(startTime);
+    const endMinutes = parseTimeToMinutes(endTime);
+    if (days.length > 0 && startMinutes !== null && endMinutes !== null) {
+      for (const day of days) {
+        windows.push({
+          day,
+          startMinutes,
+          endMinutes
+        });
+      }
+    }
+  }
+  const dayPresetPattern = /(weekdays?|weekends?|monday|tuesday|wednesday|thursday|friday|saturday|sunday|mon|tue|wed|thu|fri|sat|sun|daily|every\s*day)\s+(morning|afternoon|evening|business\s*hours?|work\s*hours?)/gi;
+  while ((match = dayPresetPattern.exec(normalized)) !== null) {
+    const dayPart = match[1];
+    const timePart = match[2].toLowerCase();
+    const days = parseDays(dayPart);
+    const timeRange = TIME_PRESETS[timePart] || TIME_PRESETS[timePart.replace(/s$/, "")];
+    if (days.length > 0 && timeRange) {
+      for (const day of days) {
+        const exists = windows.some(
+          (w) => w.day === day && w.startMinutes === timeRange.start && w.endMinutes === timeRange.end
+        );
+        if (!exists) {
+          windows.push({
+            day,
+            startMinutes: timeRange.start,
+            endMinutes: timeRange.end
+          });
+        }
+      }
+    }
+  }
+  if (windows.length === 0) {
+    for (const [preset, range] of Object.entries(TIME_PRESETS)) {
+      if (normalized.includes(preset)) {
+        for (const day of ["mon", "tue", "wed", "thu", "fri"]) {
+          windows.push({
+            day,
+            startMinutes: range.start,
+            endMinutes: range.end
+          });
+        }
+        break;
+      }
+    }
+  }
+  if (windows.length === 0) {
+    return null;
+  }
+  return { windows, timeZone };
+};
+var formatTime = (minutes) => {
+  const hours = Math.floor(minutes / 60);
+  const mins = minutes % 60;
+  const period = hours >= 12 ? "pm" : "am";
+  const displayHours = hours > 12 ? hours - 12 : hours === 0 ? 12 : hours;
+  return mins > 0 ? `${displayHours}:${mins.toString().padStart(2, "0")}${period}` : `${displayHours}${period}`;
+};
+var formatDay = (day) => {
+  const names = {
+    mon: "Monday",
+    tue: "Tuesday",
+    wed: "Wednesday",
+    thu: "Thursday",
+    fri: "Friday",
+    sat: "Saturday",
+    sun: "Sunday"
+  };
+  return names[day];
+};
+var setAvailabilityAction = {
+  name: "SET_AVAILABILITY",
+  similes: [
+    "UPDATE_AVAILABILITY",
+    "SET_SCHEDULE",
+    "UPDATE_SCHEDULE",
+    "SET_FREE_TIME",
+    "WHEN_FREE"
+  ],
+  description: "Set the user's availability for scheduling meetings",
+  validate: async (_runtime, message) => {
+    const text = message.content?.text?.toLowerCase() ?? "";
+    return text.includes("available") || text.includes("availability") || text.includes("free on") || text.includes("i'm free") || text.includes("can meet") || text.includes("my time") || text.includes("morning") || text.includes("afternoon") || text.includes("evening");
+  },
+  handler: async (runtime, message, _state, _options, callback) => {
+    const schedulingService = runtime.getService("SCHEDULING");
+    if (!schedulingService) {
+      await callback?.({
+        text: "Scheduling service is not available. Please try again later."
+      });
+      return { success: false };
+    }
+    const entityId = message.entityId;
+    if (!entityId) {
+      await callback?.({
+        text: "I could not identify you. Please try again."
+      });
+      return { success: false };
+    }
+    const text = message.content?.text ?? "";
+    const parsed = parseAvailabilityText(text);
+    if (!parsed || parsed.windows.length === 0) {
+      await callback?.({
+        text: `I couldn't understand your availability. Try: "weekdays 9am-5pm" or "Monday afternoons"`
+      });
+      return { success: false };
+    }
+    const defaultTimeZone = process.env.DEFAULT_TIMEZONE ?? "America/New_York";
+    let availability = await schedulingService.getAvailability(entityId);
+    if (!availability) {
+      availability = { timeZone: parsed.timeZone || defaultTimeZone, weekly: [], exceptions: [] };
+    }
+    if (parsed.timeZone) availability.timeZone = parsed.timeZone;
+    for (const newWindow of parsed.windows) {
+      const exists = availability.weekly.some(
+        (w) => w.day === newWindow.day && w.startMinutes === newWindow.startMinutes && w.endMinutes === newWindow.endMinutes
+      );
+      if (!exists) availability.weekly.push(newWindow);
+    }
+    await schedulingService.saveAvailability(entityId, availability);
+    const addedWindows = parsed.windows.map((w) => `${formatDay(w.day)} ${formatTime(w.startMinutes)}-${formatTime(w.endMinutes)}`).join(", ");
+    await callback?.({
+      text: `Got it! I've saved your availability: ${addedWindows}. I'll use this to find meeting times that work for you.`
+    });
+    return { success: true };
+  },
+  examples: [
+    [
+      {
+        name: "{{user1}}",
+        content: { text: "I'm free weekdays 9am to 5pm" }
+      },
+      {
+        name: "{{agentName}}",
+        content: {
+          text: "Got it! I've saved your availability: Monday 9am-5pm, Tuesday 9am-5pm, Wednesday 9am-5pm, Thursday 9am-5pm, Friday 9am-5pm. I'll use this to find meeting times that work for you."
+        }
+      }
+    ],
+    [
+      {
+        name: "{{user1}}",
+        content: { text: "Available Monday afternoons and Wednesday mornings" }
+      },
+      {
+        name: "{{agentName}}",
+        content: {
+          text: "Got it! I've saved your availability: Monday 12pm-5pm, Wednesday 9am-12pm. I'll use this to find meeting times that work for you."
+        }
+      }
+    ]
+  ]
+};
+
+// src/providers/scheduling-context.ts
+var formatMeetingForContext = (meeting, service) => {
+  const timeStr = service.formatSlot(meeting.slot);
+  const participants = meeting.participants.map((p) => p.name).join(", ");
+  const locationStr = meeting.location.type === "in_person" ? `at ${meeting.location.name}` : meeting.location.type === "virtual" ? "virtual meeting" : "phone call";
+  return `- "${meeting.title}" on ${timeStr} (${locationStr}) with ${participants} [${meeting.status}]`;
+};
+var schedulingContextProvider = {
+  name: "SCHEDULING_CONTEXT",
+  description: "Provides context about upcoming meetings and scheduling requests",
+  get: async (runtime, message, _state) => {
+    const schedulingService = runtime.getService("SCHEDULING");
+    if (!schedulingService) {
+      return { text: "" };
+    }
+    const entityId = message.entityId;
+    if (!entityId) {
+      return { text: "" };
+    }
+    const sections = [];
+    try {
+      const meetings = await schedulingService.getUpcomingMeetings(entityId);
+      if (meetings.length > 0) {
+        const proposedMeetings = meetings.filter((m) => m.status === "proposed");
+        const confirmedMeetings = meetings.filter(
+          (m) => m.status === "confirmed" || m.status === "scheduled"
+        );
+        if (proposedMeetings.length > 0) {
+          sections.push("Meetings pending confirmation:");
+          for (const meeting of proposedMeetings.slice(0, 3)) {
+            sections.push(formatMeetingForContext(meeting, schedulingService));
+          }
+        }
+        if (confirmedMeetings.length > 0) {
+          sections.push("\nUpcoming confirmed meetings:");
+          for (const meeting of confirmedMeetings.slice(0, 5)) {
+            sections.push(formatMeetingForContext(meeting, schedulingService));
+          }
+        }
+      }
+      const availability = await schedulingService.getAvailability(entityId);
+      if (availability) {
+        const weeklyCount = availability.weekly.length;
+        const exceptionsCount = availability.exceptions.length;
+        sections.push(
+          `
+User has ${weeklyCount} recurring availability windows set (timezone: ${availability.timeZone})`
+        );
+        if (exceptionsCount > 0) {
+          sections.push(`User has ${exceptionsCount} availability exceptions`);
+        }
+      } else {
+        sections.push("\nUser has not set their availability yet");
+      }
+    } catch {
+    }
+    if (sections.length === 0) {
+      return { text: "" };
+    }
+    return { text: `<scheduling_context>
+${sections.join("\n")}
+</scheduling_context>` };
+  }
+};
+
+// src/index.ts
+var schedulingPlugin = {
+  name: "scheduling",
+  description: "Scheduling and calendar coordination for multi-party meetings",
+  // Register the scheduling service
+  services: [SchedulingService],
+  // Actions for scheduling operations
+  actions: [scheduleMeetingAction, confirmMeetingAction, setAvailabilityAction],
+  // Provider for scheduling context
+  providers: [schedulingContextProvider]
+};
+var index_default = schedulingPlugin;
+export {
+  DEFAULT_CONFIG,
+  SchedulingService,
+  index_default as default,
+  generateIcs,
+  getAvailabilityStorage,
+  getMeetingStorage,
+  getReminderStorage,
+  getSchedulingRequestStorage,
+  parseIcs,
+  schedulingPlugin
+};