@hailer/mcp 1.2.1 → 1.3.9

package/dist/mcp/tools/calendar.js

@@ -0,0 +1,741 @@
+"use strict";
+/**
+ * Calendar Tools
+ *
+ * Tools for managing Hailer calendar events.
+ *
+ * v2 tool surface (docs/TOOL-SURFACE-V2.md):
+ * - query_events merges list_events + get_event + upcoming_events
+ * - manage_calendar merges list_calendars + create_calendar + update_calendar
+ * - update_event absorbs remove_attendee (removeAttendees param)
+ * - delete_calendar stays a separate NUCLEAR tool (deliberate deviation from the doc)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calendarTools = exports.respondToInviteTool = exports.deleteEventTool = exports.updateEventTool = exports.createEventTool = exports.deleteCalendarTool = exports.manageCalendarTool = exports.queryEventsTool = void 0;
+const zod_1 = require("zod");
+const tool_registry_1 = require("../tool-registry");
+const logger_1 = require("../../lib/logger");
+const request_logger_1 = require("../../lib/request-logger");
+const logger = (0, logger_1.createLogger)({ component: 'calendar-tools' });
+const VALID_ID_LENGTH = 24;
+const TIME_OPTS = { hour: '2-digit', minute: '2-digit' };
+/** Convert ISO string or timestamp to ms timestamp, returns NaN on failure */
+function toTimestamp(value) {
+    return typeof value === 'string' ? new Date(value).getTime() : value;
+}
+/** True when an optional string|number param was actually passed (0 and '' count as provided) */
+function isProvided(value) {
+    return typeof value === 'number' || typeof value === 'string';
+}
+// ============================================================================
+// QUERY EVENTS TOOL (merges list_events + get_event + upcoming_events)
+// ============================================================================
+/** Single-event mode — former get_event body */
+async function loadSingleEvent(eventId, context) {
+    try {
+        const event = await context.hailer.request('calendar.load_event', [eventId]);
+        if (!event) {
+            return { content: [{ type: 'text', text: `No event found with ID \`${eventId}\`.` }] };
+        }
+        let text = `📅 **${event.title || 'Untitled'}**\n\n`;
+        const startDate = new Date(event.start);
+        const endDate = new Date(event.end);
+        const allDayLine = `**When:** ${startDate.toLocaleDateString()} — ${endDate.toLocaleDateString()} (all day)\n`;
+        const timedLines = `**Start:** ${startDate.toLocaleString()}\n**End:** ${endDate.toLocaleString()}\n`;
+        text += event.allDay ? allDayLine : timedLines;
+        if (event.location) {
+            text += `**Location:** ${event.location}\n`;
+        }
+        if (event.notes) {
+            text += `**Notes:** ${event.notes}\n`;
+        }
+        if (event.calendar) {
+            text += `**Calendar:** ${event.calendar.name} (\`${event.calendar_id}\`)\n`;
+        }
+        text += `**Event ID:** \`${event._id}\`\n`;
+        if (event.repeat_id) {
+            text += `**Repeat series:** \`${event.repeat_id}\`\n`;
+        }
+        if (event.attendees && Object.keys(event.attendees).length > 0) {
+            text += `\n**Attendees:**\n`;
+            for (const [uid, status] of Object.entries(event.attendees)) {
+                const hasResponded = typeof status === 'boolean';
+                const rsvp = !hasResponded ? '⏳ pending' : status ? '✅ accepted' : '❌ declined';
+                text += `- \`${uid}\` — ${rsvp}\n`;
+            }
+        }
+        return { content: [{ type: 'text', text }] };
+    }
+    catch (error) {
+        if (!request_logger_1.RequestLogger.getCurrent()) {
+            logger.error('Error loading event', error);
+        }
+        return { content: [{ type: 'text', text: `❌ Error loading event: ${error instanceof Error ? error.message : String(error)}` }] };
+    }
+}
+/** Date-range mode — former list_events body */
+async function loadEventRange(calendarIds, startInput, endInput, context) {
+    try {
+        const start = toTimestamp(startInput);
+        const end = toTimestamp(endInput);
+        if (isNaN(start) || isNaN(end)) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `❌ Invalid date format. Use ISO date strings like "2026-04-14" or "2026-04-14T10:00:00".`,
+                    }],
+            };
+        }
+        const events = await context.hailer.request('calendar.load_events', [{
+                calendars: calendarIds,
+                start,
+                end,
+            }]);
+        if (!events || events.length === 0) {
+            const startStr = new Date(start).toLocaleDateString();
+            const endStr = new Date(end).toLocaleDateString();
+            return {
+                content: [{
+                        type: 'text',
+                        text: `No events found between ${startStr} and ${endStr}.`,
+                    }],
+            };
+        }
+        // Sort by start time
+        events.sort((first, second) => (first.start || 0) - (second.start || 0));
+        let responseText = `📅 **${events.length} Event(s) Found**\n\n`;
+        for (const event of events) {
+            const startDate = new Date(event.start);
+            const endDate = new Date(event.end);
+            responseText += `**${event.title || 'Untitled'}**\n`;
+            const allDayLine = `  All day: ${startDate.toLocaleDateString()} — ${endDate.toLocaleDateString()}\n`;
+            const startTime = startDate.toLocaleTimeString([], TIME_OPTS);
+            const endTime = endDate.toLocaleTimeString([], TIME_OPTS);
+            const timedLine = `  ${startDate.toLocaleDateString()} ${startTime} — ${endTime}\n`;
+            responseText += event.allDay ? allDayLine : timedLine;
+            if (event.location) {
+                responseText += `  Location: ${event.location}\n`;
+            }
+            if (event.notes) {
+                responseText += `  Notes: ${event.notes}\n`;
+            }
+            if (event._id) {
+                responseText += `  ID: \`${event._id}\`\n`;
+            }
+            responseText += `\n`;
+        }
+        return {
+            content: [{
+                    type: 'text',
+                    text: responseText,
+                }],
+        };
+    }
+    catch (error) {
+        if (!request_logger_1.RequestLogger.getCurrent()) {
+            logger.error('Error listing events', error);
+        }
+        return {
+            content: [{
+                    type: 'text',
+                    text: `❌ Error loading events: ${error instanceof Error ? error.message : String(error)}`,
+                }],
+        };
+    }
+}
+/** Upcoming mode — former upcoming_events body */
+async function loadUpcomingEvents(calendarIds, context) {
+    try {
+        const apiArg = calendarIds?.length ? calendarIds : undefined;
+        const events = await context.hailer.request('calendar.upcoming_events', [apiArg]);
+        if (!events || events.length === 0) {
+            return { content: [{ type: 'text', text: `No upcoming events found.` }] };
+        }
+        let text = `📅 **${events.length} Upcoming Event(s)**\n\n`;
+        for (const event of events) {
+            const startDate = new Date(event.start);
+            const endDate = new Date(event.end);
+            text += `**${event.title || 'Untitled'}**\n`;
+            const allDayLine = `  ${startDate.toLocaleDateString()} — ${endDate.toLocaleDateString()} (all day)\n`;
+            const startTime = startDate.toLocaleTimeString([], TIME_OPTS);
+            const endTime = endDate.toLocaleTimeString([], TIME_OPTS);
+            const timedLine = `  ${startDate.toLocaleDateString()} ${startTime} — ${endTime}\n`;
+            text += event.allDay ? allDayLine : timedLine;
+            if (event.location) {
+                text += `  Location: ${event.location}\n`;
+            }
+            text += `  ID: \`${event._id}\`\n\n`;
+        }
+        return { content: [{ type: 'text', text }] };
+    }
+    catch (error) {
+        if (!request_logger_1.RequestLogger.getCurrent()) {
+            logger.error('Error loading upcoming events', error);
+        }
+        return { content: [{ type: 'text', text: `❌ Error loading upcoming events: ${error instanceof Error ? error.message : String(error)}` }] };
+    }
+}
+const queryEventsDescription = `Query calendar events — three read modes in one tool.
+
+- **eventId** → full details of one event (times, location, notes, attendees with RSVP status, repeat series).
+- **start + end** (calendarIds required) → all events in the date range.
+- **No eventId/start/end** → up to 50 upcoming events where the user is creator or attendee (calendarIds = optional filter).
+
+eventId cannot be combined with start/end. Dates: ALWAYS ISO strings like '2026-04-14' or '2026-04-14T10:00:00'. Get calendar IDs from manage_calendar action 'list'.`;
+const queryEventsSchema = zod_1.z.object({
+    eventId: zod_1.z.string().optional().describe('Event ID (24 characters) — returns full details for this single event'),
+    start: zod_1.z.union([zod_1.z.number(), zod_1.z.string()]).optional().describe("Range start — ALWAYS use ISO string like '2026-04-14'. Requires end + calendarIds."),
+    end: zod_1.z.union([zod_1.z.number(), zod_1.z.string()]).optional().describe("Range end — ALWAYS use ISO string like '2026-04-20'. Requires start + calendarIds."),
+    calendarIds: zod_1.z.array(zod_1.z.string()).optional().describe('Calendar IDs — required for range queries, optional filter for upcoming events'),
+});
+exports.queryEventsTool = {
+    name: 'query_events',
+    group: tool_registry_1.ToolGroup.READ,
+    description: queryEventsDescription,
+    schema: queryEventsSchema,
+    async execute(args, context) {
+        const hasStart = isProvided(args.start);
+        const hasEnd = isProvided(args.end);
+        if (args.eventId && (hasStart || hasEnd)) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `❌ eventId cannot be combined with start/end. Pass eventId alone, or start + end + calendarIds for a range.`,
+                    }],
+            };
+        }
+        if (args.eventId) {
+            return loadSingleEvent(args.eventId, context);
+        }
+        if (hasStart !== hasEnd) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `❌ Range queries require both start and end.`,
+                    }],
+            };
+        }
+        if (hasStart && !args.calendarIds?.length) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `❌ Range queries require calendarIds — get them from manage_calendar action 'list'.`,
+                    }],
+            };
+        }
+        if (hasStart) {
+            return loadEventRange(args.calendarIds, args.start, args.end, context);
+        }
+        return loadUpcomingEvents(args.calendarIds, context);
+    },
+};
+// ============================================================================
+// MANAGE CALENDAR TOOL (merges list_calendars + create_calendar + update_calendar)
+// ============================================================================
+/** action 'list' — former list_calendars body */
+async function listCalendars(context) {
+    try {
+        const calendars = await context.hailer.request('calendar.list_all', [{}]);
+        if (!calendars || Object.keys(calendars).length === 0) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `No calendars found. The user may not have access to any calendars.`,
+                    }],
+            };
+        }
+        const calendarList = Object.entries(calendars).map(([id, cal]) => ({
+            id,
+            name: cal.name || 'Unnamed',
+            color: cal.color || null,
+        }));
+        let responseText = `📅 **${calendarList.length} Calendar(s) Found**\n\n`;
+        calendarList.forEach(cal => {
+            responseText += `- **${cal.name}** (ID: \`${cal.id}\`)\n`;
+        });
+        responseText += `\n💡 Use the calendar ID with \`create_event\` to add events.`;
+        return {
+            content: [{
+                    type: 'text',
+                    text: responseText,
+                }],
+        };
+    }
+    catch (error) {
+        if (!request_logger_1.RequestLogger.getCurrent()) {
+            logger.error('Error listing calendars', error);
+        }
+        return {
+            content: [{
+                    type: 'text',
+                    text: `❌ Error listing calendars: ${error instanceof Error ? error.message : String(error)}`,
+                }],
+        };
+    }
+}
+/** action 'create' — former create_calendar body */
+async function createCalendar(args, context) {
+    try {
+        const calData = {
+            name: args.name,
+            color: args.color,
+        };
+        if (args.description) {
+            calData.desc = args.description;
+        }
+        if (args.timezone) {
+            calData.timezone = args.timezone;
+        }
+        const result = await context.hailer.request('calendar.create_calendar', [calData]);
+        let text = `✅ **Calendar Created**\n\n`;
+        text += `**Name:** ${args.name}\n`;
+        text += `**Color:** ${args.color}\n`;
+        if (args.description) {
+            text += `**Description:** ${args.description}\n`;
+        }
+        if (args.timezone) {
+            text += `**Timezone:** ${args.timezone}\n`;
+        }
+        if (result?._id) {
+            text += `**Calendar ID:** \`${result._id}\`\n`;
+        }
+        return { content: [{ type: 'text', text }] };
+    }
+    catch (error) {
+        if (!request_logger_1.RequestLogger.getCurrent()) {
+            logger.error('Error creating calendar', error);
+        }
+        return { content: [{ type: 'text', text: `❌ Error creating calendar: ${error instanceof Error ? error.message : String(error)}` }] };
+    }
+}
+/** action 'update' — former update_calendar body */
+async function updateCalendar(args, context) {
+    try {
+        const calData = {
+            _id: args.calendarId,
+            name: args.name,
+            color: args.color,
+        };
+        if (typeof args.description === 'string') {
+            calData.description = args.description;
+        }
+        if (args.timezone) {
+            calData.timezone = args.timezone;
+        }
+        if (typeof args.allowGuests === 'boolean') {
+            calData.allowGuests = args.allowGuests;
+        }
+        await context.hailer.request('calendar.update_calendar', [calData]);
+        let text = `✅ **Calendar Updated**\n\n`;
+        text += `**Name:** ${args.name}\n`;
+        text += `**Color:** ${args.color}\n`;
+        return { content: [{ type: 'text', text }] };
+    }
+    catch (error) {
+        if (!request_logger_1.RequestLogger.getCurrent()) {
+            logger.error('Error updating calendar', error);
+        }
+        return { content: [{ type: 'text', text: `❌ Error updating calendar: ${error instanceof Error ? error.message : String(error)}` }] };
+    }
+}
+const manageCalendarDescription = `List, create, or update calendars — pick with the action param.
+
+- **action 'list'** → all calendars the user can access, with IDs (needed for events).
+- **action 'create'** → requires name + color (hex like '#4A90D9'); optional description, timezone. Workspace admin only.
+- **action 'update'** → requires calendarId + name + color — the API REPLACES these values, so run 'list' first to preserve current ones; optional description, timezone, allowGuests. Calendar admin only.
+
+Deleting a calendar is a separate tool: delete_calendar.`;
+const manageCalendarSchema = zod_1.z.object({
+    action: zod_1.z.enum(['list', 'create', 'update']).describe("'list' = all calendars, 'create' = new calendar, 'update' = modify existing"),
+    calendarId: zod_1.z.string().optional().describe("Calendar ID (24 characters) — required for 'update'"),
+    name: zod_1.z.string().optional().describe("Calendar name — required for 'create' and 'update'"),
+    color: zod_1.z.string().optional().describe("Hex color code (e.g. '#4A90D9') — required for 'create' and 'update'"),
+    description: zod_1.z.string().optional().describe('Calendar description'),
+    timezone: zod_1.z.string().optional().describe("Timezone (e.g. 'Europe/Helsinki')"),
+    allowGuests: zod_1.z.boolean().optional().describe("Allow guest users to access this calendar ('update' only)"),
+});
+exports.manageCalendarTool = {
+    name: 'manage_calendar',
+    group: tool_registry_1.ToolGroup.WRITE,
+    description: manageCalendarDescription,
+    schema: manageCalendarSchema,
+    async execute(args, context) {
+        if (args.action === 'list') {
+            return listCalendars(context);
+        }
+        if (!args.name || !args.color) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `❌ action '${args.action}' requires both name and color.`,
+                    }],
+            };
+        }
+        if (args.action === 'create') {
+            return createCalendar(args, context);
+        }
+        if (!args.calendarId) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `❌ action 'update' requires calendarId — get it from manage_calendar action 'list'.`,
+                    }],
+            };
+        }
+        return updateCalendar(args, context);
+    },
+};
+// ============================================================================
+// DELETE CALENDAR TOOL (unchanged — stays a separate NUCLEAR tool)
+// ============================================================================
+exports.deleteCalendarTool = {
+    name: 'delete_calendar',
+    group: tool_registry_1.ToolGroup.NUCLEAR,
+    description: `Delete a calendar and all its events.
+
+**⚠️ DESTRUCTIVE:** This permanently removes the calendar and all associated events. This cannot be undone.
+
+**Example:**
+\`\`\`javascript
+delete_calendar({ calendarId: "69ccde43..." })
+\`\`\`
+
+**Requirements:** User must be a calendar admin.`,
+    schema: zod_1.z.object({
+        calendarId: zod_1.z.string().describe("Calendar ID to delete (24 characters)"),
+    }),
+    async execute(args, context) {
+        try {
+            if (args.calendarId.length !== VALID_ID_LENGTH) {
+                return { content: [{ type: "text", text: `Invalid calendarId — must be a 24-character ID.` }] };
+            }
+            await context.hailer.request('calendar.remove_calendar', [args.calendarId]);
+            return { content: [{ type: "text", text: `✅ **Calendar Deleted**\n\nCalendar \`${args.calendarId}\` and all its events have been permanently removed.` }] };
+        }
+        catch (error) {
+            if (!request_logger_1.RequestLogger.getCurrent())
+                logger.error("Error deleting calendar", error);
+            return { content: [{ type: "text", text: `❌ Error deleting calendar: ${error instanceof Error ? error.message : String(error)}` }] };
+        }
+    },
+};
+// ============================================================================
+// CREATE EVENT TOOL
+// ============================================================================
+const createEventDescription = `Create a calendar event. Requires a 24-character calendarId — get it from manage_calendar action 'list'; the user must have access to the calendar.
+
+**Dates:** ALWAYS pass ISO strings — NEVER compute timestamps manually (the tool converts). Timed events: 'YYYY-MM-DDTHH:MM:SS' (e.g. '2026-07-10T10:00:00'). All-day events: 'YYYY-MM-DD' with allDay: true. European 'DD.MM.YYYY' dates mean day-first — '10.07.2026' is July 10, 2026 → '2026-07-10'.
+
+**Attendees:** pass attendeeUserIds — ALWAYS include the requesting user's ID from <context>.`;
+const createEventSchema = zod_1.z.object({
+    calendarId: zod_1.z.string().describe("Calendar ID (24 characters) — get from manage_calendar action 'list'"),
+    title: zod_1.z.string().describe('Event title'),
+    start: zod_1.z.union([zod_1.z.number(), zod_1.z.string()]).describe("Start time — ALWAYS use ISO string like '2026-07-10T10:00:00'. Never compute timestamps."),
+    end: zod_1.z.union([zod_1.z.number(), zod_1.z.string()]).describe("End time — ALWAYS use ISO string like '2026-07-10T11:00:00'. Never compute timestamps."),
+    allDay: zod_1.z.boolean().optional().default(false).describe('Whether this is an all-day event'),
+    location: zod_1.z.string().optional().describe('Event location'),
+    notes: zod_1.z.string().optional().describe('Event description/notes'),
+    attendeeUserIds: zod_1.z.array(zod_1.z.string()).optional().describe("User IDs to add as attendees. CRITICAL: always include the requesting user's ID from <context>."),
+});
+exports.createEventTool = {
+    name: 'create_event',
+    group: tool_registry_1.ToolGroup.WRITE,
+    description: createEventDescription,
+    schema: createEventSchema,
+    async execute(args, context) {
+        logger.debug('Creating calendar event', {
+            calendarId: args.calendarId,
+            title: args.title,
+        });
+        try {
+            if (args.calendarId.length !== 24) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `Invalid calendarId "${args.calendarId}" - must be a 24-character ID.\n\nUse \`manage_calendar\` action 'list' to find valid calendar IDs.`,
+                        }],
+                };
+            }
+            // Auto-convert date strings to timestamps
+            const start = typeof args.start === 'string' ? new Date(args.start).getTime() : args.start;
+            const end = typeof args.end === 'string' ? new Date(args.end).getTime() : args.end;
+            if (isNaN(start) || isNaN(end)) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `❌ Invalid date format. Use Unix timestamps in milliseconds or ISO date strings (e.g. "2026-04-15T10:00:00").`,
+                        }],
+                };
+            }
+            const eventData = {
+                calendar_id: args.calendarId,
+                title: args.title,
+                start,
+                end,
+                allDay: args.allDay || false,
+            };
+            if (args.location) {
+                eventData.location = args.location;
+            }
+            if (args.notes) {
+                eventData.notes = args.notes;
+            }
+            // Convert attendeeUserIds array to attendees object format: { "userId": true }
+            if (args.attendeeUserIds?.length) {
+                const attendees = {};
+                for (const userId of args.attendeeUserIds) {
+                    attendees[userId] = true;
+                }
+                eventData.attendees = attendees;
+            }
+            const result = await context.hailer.request('calendar.create_event', [eventData]);
+            const createdEvent = Array.isArray(result) ? result[0] : result;
+            let responseText = `✅ **Event Created**\n\n`;
+            responseText += `**Title:** ${args.title}\n`;
+            responseText += `**Start:** ${new Date(start).toLocaleString()}\n`;
+            responseText += `**End:** ${new Date(end).toLocaleString()}\n`;
+            if (args.allDay) {
+                responseText += `**All day:** Yes\n`;
+            }
+            if (args.location) {
+                responseText += `**Location:** ${args.location}\n`;
+            }
+            if (args.notes) {
+                responseText += `**Notes:** ${args.notes}\n`;
+            }
+            if (createdEvent?._id) {
+                responseText += `**Event ID:** \`${createdEvent._id}\`\n`;
+            }
+            return {
+                content: [{
+                        type: 'text',
+                        text: responseText,
+                    }],
+            };
+        }
+        catch (error) {
+            if (!request_logger_1.RequestLogger.getCurrent()) {
+                logger.error('Error creating event', error);
+            }
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return {
+                content: [{
+                        type: 'text',
+                        text: `❌ **Error creating event**\n\n**Error:** ${errorMessage}\n\n**Common Issues:**\n- Calendar ID must be valid (use \`manage_calendar\` action 'list')\n- Start and end times are required\n- User must have access to the calendar`,
+                    }],
+            };
+        }
+    },
+};
+// ============================================================================
+// UPDATE EVENT TOOL (absorbs remove_attendee via removeAttendees)
+// ============================================================================
+const updateEventDescription = `Update a calendar event. The API REPLACES event data — eventId, calendarId, title, start, end are ALL required; load the event first (query_events) to preserve unchanged fields. Dates: ISO strings like '2026-04-20T14:00:00'. attendeeUserIds REPLACES the full attendee list.
+
+**removeAttendees:** user IDs to uninvite — each is also removed from the event's linked discussion. Runs after the field update; combinable with other changes in one call.
+
+**repeatUpdate** (repeating events only): 'single' = this occurrence, 'future' = this and later, 'all' = entire series.`;
+const updateEventSchema = zod_1.z.object({
+    eventId: zod_1.z.string().describe('Event ID to update (24 characters)'),
+    calendarId: zod_1.z.string().optional()
+        .describe('Calendar ID the event belongs to (24 chars). Required unless ONLY removing attendees'),
+    title: zod_1.z.string().optional().describe('Event title. Required unless ONLY removing attendees'),
+    start: zod_1.z.union([zod_1.z.number(), zod_1.z.string()]).optional()
+        .describe("Start time — ISO string like '2026-04-20T14:00:00'. Required unless ONLY removing attendees"),
+    end: zod_1.z.union([zod_1.z.number(), zod_1.z.string()]).optional()
+        .describe("End time — ISO string like '2026-04-20T15:00:00'. Required unless ONLY removing attendees"),
+    allDay: zod_1.z.boolean().optional().default(false).describe('Whether this is an all-day event'),
+    location: zod_1.z.string().optional().describe('Event location'),
+    notes: zod_1.z.string().optional().describe('Event description/notes'),
+    attendeeUserIds: zod_1.z.array(zod_1.z.string()).optional().describe('User IDs as attendees — replaces existing attendees'),
+    removeAttendees: zod_1.z.array(zod_1.z.string()).optional().describe("User IDs to remove as attendees — also removed from the event's linked discussion"),
+    repeatUpdate: zod_1.z.enum(['single', 'future', 'all']).optional().describe("For repeating events: update 'single', 'future', or 'all' occurrences"),
+});
+async function runEventFieldUpdate(args, start, end, context) {
+    const eventData = {
+        _id: args.eventId,
+        calendar_id: args.calendarId,
+        title: args.title,
+        start,
+        end,
+        allDay: args.allDay || false,
+    };
+    if (typeof args.location === 'string') {
+        eventData.location = args.location;
+    }
+    if (typeof args.notes === 'string') {
+        eventData.notes = args.notes;
+    }
+    if (args.attendeeUserIds?.length) {
+        const attendees = {};
+        for (const userId of args.attendeeUserIds) {
+            attendees[userId] = true;
+        }
+        eventData.attendees = attendees;
+    }
+    const updateOptions = {};
+    if (args.repeatUpdate) {
+        updateOptions.update = args.repeatUpdate;
+    }
+    await context.hailer.request('calendar.update_event', [eventData, updateOptions]);
+}
+exports.updateEventTool = {
+    name: 'update_event',
+    group: tool_registry_1.ToolGroup.WRITE,
+    description: updateEventDescription,
+    schema: updateEventSchema,
+    async execute(args, context) {
+        try {
+            // Attendee-removal-only calls (incl. the remove_attendee alias) skip
+            // the field update — they don't need the full event payload.
+            const isFieldUpdate = Boolean(args.calendarId || args.title || args.start || args.end);
+            const hasFullPayload = Boolean(args.calendarId && args.title && args.start && args.end);
+            if (isFieldUpdate && !hasFullPayload) {
+                const text = '❌ Field updates REPLACE event data — calendarId, title, start, and end are all required. '
+                    + 'Load the event first with query_events.';
+                return { content: [{ type: 'text', text }] };
+            }
+            if (!isFieldUpdate && !args.removeAttendees?.length) {
+                return { content: [{ type: 'text', text: '❌ Nothing to update — provide event fields (calendarId, title, start, end) and/or removeAttendees.' }] };
+            }
+            const start = toTimestamp(args.start ?? 0);
+            const end = toTimestamp(args.end ?? 0);
+            if (isFieldUpdate && (isNaN(start) || isNaN(end))) {
+                return { content: [{ type: 'text', text: `❌ Invalid date format. Use ISO strings like "2026-04-20T14:00:00".` }] };
+            }
+            if (isFieldUpdate) {
+                await runEventFieldUpdate(args, start, end, context);
+            }
+            // Attendee removal — former remove_attendee logic, one calendar.remove_invite per user
+            // (the server also removes each user from the event's linked discussion)
+            const removed = [];
+            const removeFailures = [];
+            for (const userId of args.removeAttendees ?? []) {
+                try {
+                    await context.hailer.request('calendar.remove_invite', [args.eventId, userId]);
+                    removed.push(userId);
+                }
+                catch (removeError) {
+                    const reason = removeError instanceof Error ? removeError.message : String(removeError);
+                    removeFailures.push(`\`${userId}\` — ${reason}`);
+                }
+            }
+            let text = `✅ **Event Updated**\n\n`;
+            if (isFieldUpdate) {
+                text += `**Title:** ${args.title}\n`;
+                text += `**Start:** ${new Date(start).toLocaleString()}\n`;
+                text += `**End:** ${new Date(end).toLocaleString()}\n`;
+            }
+            if (args.repeatUpdate) {
+                text += `**Repeat scope:** ${args.repeatUpdate}\n`;
+            }
+            if (removed.length) {
+                text += `**Removed attendees:** ${removed.map(uid => `\`${uid}\``).join(', ')}\n`;
+            }
+            if (removeFailures.length) {
+                text += `\n❌ **Failed to remove attendees:**\n${removeFailures.map(entry => `- ${entry}`).join('\n')}\n`;
+            }
+            return { content: [{ type: 'text', text }] };
+        }
+        catch (error) {
+            if (!request_logger_1.RequestLogger.getCurrent()) {
+                logger.error('Error updating event', error);
+            }
+            return { content: [{ type: 'text', text: `❌ Error updating event: ${error instanceof Error ? error.message : String(error)}` }] };
+        }
+    },
+};
+// ============================================================================
+// DELETE EVENT TOOL (unchanged)
+// ============================================================================
+exports.deleteEventTool = {
+    name: 'delete_event',
+    group: tool_registry_1.ToolGroup.WRITE,
+    description: `Delete a calendar event.
+
+**Examples:**
+
+Delete single event:
+\`\`\`javascript
+delete_event({ eventId: "69ccde43..." })
+\`\`\`
+
+Delete entire repeating series:
+\`\`\`javascript
+delete_event({ eventId: "69ccde43...", repeatDelete: "all" })
+\`\`\`
+
+**repeatDelete options** (only for repeating events):
+- \`"single"\` — delete only this occurrence (default)
+- \`"future"\` — delete this and all future occurrences
+- \`"all"\` — delete the entire series`,
+    schema: zod_1.z.object({
+        eventId: zod_1.z.string().describe("Event ID to delete (24 characters)"),
+        repeatDelete: zod_1.z.enum(['single', 'future', 'all']).optional().describe("For repeating events: delete 'single', 'future', or 'all'"),
+    }),
+    async execute(args, context) {
+        try {
+            const removeOptions = {};
+            if (args.repeatDelete) {
+                removeOptions.remove = args.repeatDelete;
+            }
+            await context.hailer.request('calendar.remove_event', [args.eventId, removeOptions]);
+            let text = `✅ **Event Deleted**\n`;
+            if (args.repeatDelete)
+                text += `Scope: ${args.repeatDelete}\n`;
+            return { content: [{ type: "text", text }] };
+        }
+        catch (error) {
+            if (!request_logger_1.RequestLogger.getCurrent())
+                logger.error("Error deleting event", error);
+            return { content: [{ type: "text", text: `❌ Error deleting event: ${error instanceof Error ? error.message : String(error)}` }] };
+        }
+    },
+};
+// ============================================================================
+// RESPOND TO INVITE TOOL (unchanged)
+// ============================================================================
+exports.respondToInviteTool = {
+    name: 'respond_to_invite',
+    group: tool_registry_1.ToolGroup.WRITE,
+    description: `Accept or decline a calendar event invitation.
+
+**Examples:**
+
+Accept:
+\`\`\`javascript
+respond_to_invite({ eventId: "69ccde43...", attending: true })
+\`\`\`
+
+Decline:
+\`\`\`javascript
+respond_to_invite({ eventId: "69ccde43...", attending: false })
+\`\`\``,
+    schema: zod_1.z.object({
+        eventId: zod_1.z.string().describe("Event ID to respond to (24 characters)"),
+        attending: zod_1.z.boolean().describe("true = accept, false = decline"),
+    }),
+    async execute(args, context) {
+        try {
+            const attendingMap = { [args.eventId]: args.attending };
+            await context.hailer.request('calendar.invite_respond', [attendingMap]);
+            const status = args.attending ? 'accepted ✅' : 'declined ❌';
+            return { content: [{ type: "text", text: `Event invitation ${status}.` }] };
+        }
+        catch (error) {
+            if (!request_logger_1.RequestLogger.getCurrent())
+                logger.error("Error responding to invite", error);
+            return { content: [{ type: "text", text: `❌ Error responding to invite: ${error instanceof Error ? error.message : String(error)}` }] };
+        }
+    },
+};
+exports.calendarTools = [
+    exports.queryEventsTool,
+    exports.manageCalendarTool,
+    exports.deleteCalendarTool,
+    exports.createEventTool,
+    exports.updateEventTool,
+    exports.deleteEventTool,
+    exports.respondToInviteTool,
+];
+//# sourceMappingURL=calendar.js.map