@chrischall/office-outlook-mcp 0.4.1 → 0.5.0

package/dist/bundle.js

@@ -35616,6 +35616,11 @@ function textResult(data) {
     content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
   };
 }
+function imageResult(base643, mimeType) {
+  return {
+    content: [{ type: "image", data: base643, mimeType }]
+  };
+}
 function errorResult(message) {
   return {
     content: [{ type: "text", text: redactSecrets(message) }],
@@ -37474,6 +37479,18 @@ var init_verify_after_write = __esm({
 });
 
 // node_modules/@chrischall/mcp-utils/dist/concurrency/index.js
+async function mapWithConcurrency(items, limit, fn) {
+  const results = new Array(items.length);
+  let next = 0;
+  const poolSize = Math.min(Math.max(limit, 1), items.length);
+  await Promise.all(Array.from({ length: poolSize }, async () => {
+    while (next < items.length) {
+      const i = next++;
+      results[i] = await fn(items[i], i);
+    }
+  }));
+  return results;
+}
 var init_concurrency = __esm({
   "node_modules/@chrischall/mcp-utils/dist/concurrency/index.js"() {
     init_single_flight();
@@ -37571,7 +37588,7 @@ var init_version = __esm({
   "src/version.ts"() {
     "use strict";
     PACKAGE_NAME = "office-outlook-mcp";
-    VERSION = "0.4.1";
+    VERSION = "0.5.0";
   }
 });
 
@@ -48663,6 +48680,10 @@ function toBearerTokens(accessToken) {
   }
   return { accessToken, refreshToken: RECAPTURE_SENTINEL, expiresAt };
 }
+function isCredentialFailure(e) {
+  const kind = errorKindOf(e);
+  return kind === "no_credential" || kind === "credential_rejected" || errorStatusOf(e) === 401;
+}
 var OutlookClient = class {
   #baseUrl;
   /**
@@ -48690,7 +48711,8 @@ var OutlookClient = class {
       this.#configError = new McpToolError(
         "No Outlook credential is configured.",
         {
-          hint: "Set OUTLOOK_ACCESS_TOKEN, or unset OUTLOOK_DISABLE_FETCHPROXY so the token can be captured from a signed-in Outlook browser tab."
+          hint: "Set OUTLOOK_ACCESS_TOKEN, or unset OUTLOOK_DISABLE_FETCHPROXY so the token can be captured from a signed-in Outlook browser tab.",
+          kind: "no_credential"
         }
       );
     }
@@ -48721,7 +48743,9 @@ var OutlookClient = class {
       refresh: async () => {
         if (direct !== void 0) {
           throw new McpToolError("OUTLOOK_ACCESS_TOKEN was rejected by Outlook.", {
-            hint: "A directly-supplied token cannot be refreshed automatically. Replace OUTLOOK_ACCESS_TOKEN with a current one, or unset it to capture from a signed-in Outlook browser tab instead."
+            hint: "A directly-supplied token cannot be refreshed automatically. Replace OUTLOOK_ACCESS_TOKEN with a current one, or unset it to capture from a signed-in Outlook browser tab instead.",
+            status: 401,
+            kind: "credential_rejected"
           });
         }
         return toBearerTokens(await this.#capture());
@@ -48760,7 +48784,9 @@ var OutlookClient = class {
       timeout: 6e4,
       baseHeaders: { Accept: "application/json" },
       onUnauthorized: () => new McpToolError("Outlook rejected the access token (401).", {
-        hint: "The token has expired or been revoked. Open a signed-in Outlook tab and retry \u2014 the next call re-captures automatically."
+        hint: "The token has expired or been revoked. Open a signed-in Outlook tab and retry \u2014 the next call re-captures automatically.",
+        status: 401,
+        kind: "credential_rejected"
       })
     });
     return this.#api;
@@ -48883,12 +48909,21 @@ function addrs(list) {
   if (!Array.isArray(list) || list.length === 0) return void 0;
   return list.map((r) => addr(r)).filter((s) => s !== void 0);
 }
+var MAX_RECIPIENTS = 20;
+function cappedRecipients(key, list) {
+  if (list === void 0 || list.length <= MAX_RECIPIENTS) return { [key]: list };
+  return {
+    [key]: list.slice(0, MAX_RECIPIENTS),
+    [`${key}Count`]: list.length,
+    [`${key}Truncated`]: true
+  };
+}
 function compactMessage(m) {
   return pruned({
     Id: m.Id,
     Subject: m.Subject,
     From: addr(m.From ?? m.Sender),
-    To: addrs(m.ToRecipients),
+    ...cappedRecipients("To", addrs(m.ToRecipients)),
     Received: m.ReceivedDateTime,
     IsRead: m.IsRead,
     HasAttachments: m.HasAttachments || void 0,
@@ -48901,7 +48936,7 @@ function compactMessage(m) {
 function fullMessage(m) {
   return pruned({
     ...compactMessage(m),
-    Cc: addrs(m.CcRecipients),
+    ...cappedRecipients("Cc", addrs(m.CcRecipients)),
     Sent: m.SentDateTime,
     Importance: m.Importance,
     IsDraft: m.IsDraft,
@@ -48920,14 +48955,19 @@ function compactEvent(e) {
     TimeZone: e.Start?.TimeZone,
     Location: e.Location?.DisplayName || void 0,
     Organizer: addr(e.Organizer),
-    IsAllDay: e.IsAllDay || void 0,
-    IsCancelled: e.IsCancelled || void 0
+    IsAllDay: e.IsAllDay,
+    IsCancelled: e.IsCancelled,
+    IsOrganizer: e.IsOrganizer,
+    MyResponse: e.ResponseStatus?.Response,
+    ResponseRequested: e.ResponseRequested,
+    Type: e.Type,
+    ShowAs: e.ShowAs
   });
 }
 function fullEvent(e) {
   return pruned({
     ...compactEvent(e),
-    ShowAs: e.ShowAs,
+    SeriesMasterId: e.SeriesMasterId,
     Attendees: e.Attendees?.map(
       (a) => pruned({ Who: addr(a), Response: a.Status?.Response })
     ),
@@ -48975,6 +49015,17 @@ function projectCollection(payload, project, label) {
   });
 }
 
+// src/tools/_invite.ts
+var EVENT_EXPAND = "Microsoft.OutlookServices.EventMessage/Event";
+function resolvedEvent(e) {
+  return e?.Id ? e : void 0;
+}
+var INVITE_GONE = "the meeting is no longer on your calendar (already declined, cancelled, or deleted), so there is nothing to respond to";
+var MEETING_MESSAGE_TYPE = "Microsoft.OutlookServices.EventMessage/MeetingMessageType";
+function isMeetingMessage(m) {
+  return !!m?.MeetingMessageType || (m?.["@odata.type"] ?? "").includes("EventMessage");
+}
+
 // src/tools/_paging.ts
 init_zod();
 var nextLinkParam = external_exports.string().min(1).optional().describe(
@@ -49016,6 +49067,91 @@ var LIST_SELECT = "Id,Subject,From,ToRecipients,ReceivedDateTime,IsRead,HasAttac
 function folderSegment(folder) {
   return encodeURIComponent(folder);
 }
+var UNREAD_SELECT = [
+  "Id",
+  "Subject",
+  "From",
+  "ToRecipients",
+  "CcRecipients",
+  "ReceivedDateTime",
+  "Importance",
+  "HasAttachments",
+  "Categories",
+  "Flag",
+  "ConversationId",
+  MEETING_MESSAGE_TYPE
+].join(",");
+var BODY_CONCURRENCY = 4;
+function triageKind(m) {
+  switch (m.MeetingMessageType) {
+    case "MeetingRequest":
+      return "meetingRequest";
+    case "MeetingCancelled":
+      return "meetingCancelled";
+    case "MeetingAccepted":
+    case "MeetingTenativelyAccepted":
+    // sic — Outlook's spelling
+    case "MeetingTentativelyAccepted":
+    case "MeetingDeclined":
+      return "meetingResponse";
+  }
+  const type = m["@odata.type"] ?? "";
+  if (!type.includes("EventMessage")) return "mail";
+  if (/Request$/.test(type)) return "meetingRequest";
+  if (/Cancel/.test(type)) return "meetingCancelled";
+  return "meetingResponse";
+}
+function triageEvent(e) {
+  return stripUndefined({
+    id: e.Id,
+    subject: e.Subject,
+    start: e.Start?.DateTime,
+    end: e.End?.DateTime,
+    timeZone: e.Start?.TimeZone,
+    location: e.Location?.DisplayName || void 0,
+    organizer: addr(e.Organizer),
+    responseStatus: e.ResponseStatus?.Response,
+    isCancelled: e.IsCancelled
+  });
+}
+var INVITE_UNRESOLVED_HINT = `This invite's ${INVITE_GONE}.`;
+function truncateChars(text, max) {
+  const end = /[\uD800-\uDBFF]/.test(text.charAt(max - 1)) ? max - 1 : max;
+  return text.slice(0, end);
+}
+function stripUndefined(o) {
+  return Object.fromEntries(Object.entries(o).filter(([, v]) => v !== void 0));
+}
+var ATTACHMENT_META_SELECT = "Id,Name,ContentType,Size,IsInline";
+var MAX_INLINE_BYTES = 5 * 1024 * 1024;
+var MAX_TEXT_BYTES = 200 * 1024;
+var TEXT_TYPE = /^text\/|^application\/(json|xml|csv|ics|calendar)\b|\+(json|xml)$/i;
+var TEXT_EXT = /\.(txt|csv|tsv|json|xml|ics|md|log|html?)$/i;
+function attachmentKind(a) {
+  const type = a["@odata.type"] ?? "";
+  if (/ItemAttachment$/.test(type)) return "item";
+  if (/ReferenceAttachment$/.test(type)) return "reference";
+  return "file";
+}
+function isImage(contentType) {
+  return /^image\//i.test(contentType) && !/svg/i.test(contentType);
+}
+function isText(contentType, name) {
+  return TEXT_TYPE.test(contentType) || /svg/i.test(contentType) || TEXT_EXT.test(name);
+}
+function base64DecodedLength(b64) {
+  const padding = b64.endsWith("==") ? 2 : b64.endsWith("=") ? 1 : 0;
+  return Math.floor(b64.length * 3 / 4) - padding;
+}
+function utf8Boundary(buf, max) {
+  if (buf.length <= max) return buf.length;
+  let end = max;
+  while (end > 0 && (buf[end] & 192) === 128) end--;
+  return end;
+}
+function sinceLiteral(hours) {
+  return new Date(Date.now() - hours * 36e5).toISOString().replace(/\.\d{3}Z$/, "Z");
+}
 function registerMailTools(server, client2) {
   server.registerTool(
     "outlook_list_folders",
@@ -49044,7 +49180,7 @@ function registerMailTools(server, client2) {
   server.registerTool(
     "outlook_list_messages",
     {
-      description: "List messages in a folder, newest first. Defaults to the inbox. Use `unreadOnly` for a triage view. Bodies are NOT included \u2014 call outlook_get_message for one. Note `search` and `unreadOnly` cannot be combined on a first-page request (the API rejects $search with $filter); pass `search` alone to search the whole mailbox. When following a `nextLink`, both are ignored, so echoing them back is harmless. " + UNTRUSTED_DESCRIPTION_SUFFIX,
+      description: 'List messages in a folder, newest first. Defaults to the inbox. Use `unreadOnly` for a triage view. Bodies are NOT included \u2014 call outlook_get_message for one. Note `search` and `unreadOnly` cannot be combined on a first-page request (the API rejects $search with $filter); pass `search` alone to search the whole mailbox. When following a `nextLink`, both are ignored, so echoing them back is harmless. Each message\'s To list (and Cc, in the full view) holds at most 20 addresses; a longer list adds ToCount/ToTruncated (CcCount/CcTruncated) with the full count \u2014 pass view:"raw" for every address. ' + UNTRUSTED_DESCRIPTION_SUFFIX,
       annotations: { readOnlyHint: true, openWorldHint: true },
       inputSchema: external_exports.object({
         view: viewParam(VIEWS2),
@@ -49090,7 +49226,7 @@ function registerMailTools(server, client2) {
   server.registerTool(
     "outlook_get_message",
     {
-      description: `Get one message including its body. The body is requested as plain text rather than HTML (measured ~9x smaller and far easier to read); pass view:"raw" to get Outlook's untouched record. ` + UNTRUSTED_DESCRIPTION_SUFFIX,
+      description: `Get one message including its body. The body is requested as plain text rather than HTML (measured ~9x smaller and far easier to read); pass view:"raw" to get Outlook's untouched record. To and Cc list at most 20 addresses; a longer list adds ToCount/ToTruncated (CcCount/CcTruncated) with the full count \u2014 view:"raw" returns every address. ` + UNTRUSTED_DESCRIPTION_SUFFIX,
       annotations: { readOnlyHint: true, openWorldHint: true },
       inputSchema: external_exports.object({
         view: viewParam(VIEWS2),
@@ -49107,6 +49243,91 @@ function registerMailTools(server, client2) {
       return mailboxUntrusted(v === "full" ? fullMessage(data) : compactMessage(data));
     }
   );
+  server.registerTool(
+    "outlook_get_unread",
+    {
+      description: 'Triage batch: the unread messages in a folder (default inbox), newest first, each WITH its plain-text body (truncated to `maxBodyChars`) in one call \u2014 no follow-up outlook_get_message needed. Every item has a `kind`: "mail", "meetingRequest", "meetingCancelled" or "meetingResponse" (a reply to an invite you sent). Requests and cancellations also carry `event` (id, time, organizer, your current `responseStatus`) so the invite can be answered by its event id (when the meeting is no longer on your calendar \u2014 already declined, cancelled or deleted \u2014 the item has a `hint` instead and there is nothing to respond to). `to`/`cc` list at most 20 addresses; a longer list adds `toCount`/`ccCount` and `toTruncated`/`ccTruncated`. This does NOT mark anything read. Processing loop: read the batch \u2192 act on each item (reply, respond to the invite, file, flag \u2014 or leave it) \u2192 call outlook_mark_read on the ids you handled, so the next call returns only what is still new. Follow `nextLink` for more. ' + UNTRUSTED_DESCRIPTION_SUFFIX,
+      annotations: { readOnlyHint: true, openWorldHint: true },
+      inputSchema: external_exports.object({
+        folder: external_exports.string().min(1).optional().describe('Folder id or well-known name (default "inbox")'),
+        limit: external_exports.number().int().min(1).max(50).optional().describe("Max messages (default 25, max 50)"),
+        sinceHours: external_exports.number().positive().max(24 * 365).optional().describe("Only mail received in the last N hours"),
+        includeBody: external_exports.boolean().optional().describe("Fetch each plain-text body (default true). Invite events are resolved either way."),
+        maxBodyChars: external_exports.number().int().min(100).max(1e5).optional().describe("Truncate each body to this many characters (default 4000); `bodyTruncated` marks a cut"),
+        nextLink: nextLinkParam
+      })
+    },
+    async ({ folder, limit, sinceHours, includeBody, maxBodyChars, nextLink }) => {
+      const filter = [
+        sinceHours !== void 0 ? `ReceivedDateTime ge ${sinceLiteral(sinceHours)}` : void 0,
+        "IsRead eq false"
+      ].filter((c) => c !== void 0).join(" and ");
+      const data = await fetchPage(
+        client2,
+        nextLink,
+        `/me/mailfolders/${folderSegment(folder ?? "inbox")}/messages`,
+        {
+          query: {
+            $top: limit ?? 25,
+            $select: UNREAD_SELECT,
+            $filter: filter,
+            $orderby: "ReceivedDateTime desc"
+          }
+        }
+      );
+      const rows = Array.isArray(data?.value) ? data.value : [];
+      const wantBody = includeBody !== false;
+      const cap = maxBodyChars ?? 4e3;
+      const items = await mapWithConcurrency(rows, BODY_CONCURRENCY, async (m) => {
+        const kind = triageKind(m);
+        const item = stripUndefined({
+          id: m.Id,
+          kind,
+          receivedAt: m.ReceivedDateTime,
+          from: addr(m.From ?? m.Sender),
+          ...cappedRecipients("to", addrs(m.ToRecipients)),
+          ...cappedRecipients("cc", addrs(m.CcRecipients)),
+          subject: m.Subject,
+          importance: m.Importance,
+          hasAttachments: m.HasAttachments || void 0,
+          categories: m.Categories?.length ? m.Categories : void 0,
+          flag: m.Flag?.FlagStatus,
+          conversationId: m.ConversationId
+        });
+        const wantEvent = kind === "meetingRequest" || kind === "meetingCancelled";
+        if (!wantBody && !wantEvent || m.Id === void 0) return item;
+        try {
+          const one = await client2.get(
+            `/me/messages/${encodeURIComponent(m.Id)}`,
+            {
+              text: wantBody,
+              query: {
+                $select: wantBody ? "Id,Body" : "Id",
+                $expand: wantEvent ? EVENT_EXPAND : void 0
+              }
+            }
+          );
+          if (wantBody) {
+            const text = (one.Body?.Content ?? "").trim();
+            item.body = text.length > cap ? truncateChars(text, cap) : text;
+            if (text.length > cap) item.bodyTruncated = true;
+          }
+          if (wantEvent) {
+            const event = resolvedEvent(one.Event);
+            if (event) item.event = triageEvent(event);
+            else item.hint = INVITE_UNRESOLVED_HINT;
+          }
+        } catch (e) {
+          item.error = e instanceof Error ? e.message : String(e);
+        }
+        return item;
+      });
+      const out = { count: items.length, items };
+      const next = data?.["@odata.nextLink"];
+      if (next) out.nextLink = next;
+      return mailboxUntrusted(out);
+    }
+  );
   server.registerTool(
     "outlook_list_attachments",
     {
@@ -49127,6 +49348,70 @@ function registerMailTools(server, client2) {
       return minifiedResult(plainCollection(data));
     }
   );
+  server.registerTool(
+    "outlook_get_attachment",
+    {
+      description: "Get one attachment's content (ids from outlook_list_attachments). An image comes back as image content the model can see; a text-like file (text/*, JSON, CSV, XML, .ics) is decoded to `text`, capped at 200 KB (`textTruncated` marks a cut). Any other binary (PDF, Office, archives) and anything over 5 MB is returned as metadata only \u2014 its bytes are not inlined. An attached Outlook item (a forwarded email or event) or a cloud-file link has no bytes to return; the result says which. " + UNTRUSTED_DESCRIPTION_SUFFIX,
+      annotations: { readOnlyHint: true, openWorldHint: true },
+      inputSchema: external_exports.object({
+        messageId: external_exports.string().min(1).describe("Message Id"),
+        attachmentId: external_exports.string().min(1).describe("Attachment Id from outlook_list_attachments")
+      })
+    },
+    async ({ messageId, attachmentId }) => {
+      const path = `/me/messages/${encodeURIComponent(messageId)}/attachments/${encodeURIComponent(attachmentId)}`;
+      const meta3 = await client2.get(path, { query: { $select: ATTACHMENT_META_SELECT } });
+      const kind = attachmentKind(meta3);
+      const contentType = meta3.ContentType ?? "";
+      const name = meta3.Name ?? "";
+      const out = stripUndefined({
+        messageId,
+        attachmentId,
+        name: meta3.Name,
+        contentType: meta3.ContentType ?? void 0,
+        size: meta3.Size,
+        isInline: meta3.IsInline || void 0,
+        kind,
+        inlined: false
+      });
+      if (kind === "item") {
+        out.hint = "This is an attached Outlook item (an email, event or contact), not a file, so it has no bytes to return. Ask the sender for it, or open the parent message in Outlook.";
+        return mailboxUntrusted(out);
+      }
+      if (kind === "reference") {
+        out.hint = "This is a link to a cloud file (OneDrive/SharePoint), not a file stored in the message, so there are no bytes to return.";
+        return mailboxUntrusted(out);
+      }
+      const image = isImage(contentType);
+      if (!image && !isText(contentType, name)) {
+        out.hint = "Binary content is not inlined: only images and text-like files are returned. Open it in Outlook to read it.";
+        return mailboxUntrusted(out);
+      }
+      if ((meta3.Size ?? 0) > MAX_INLINE_BYTES) {
+        out.hint = "Content is not inlined above 5 MB. Open it in Outlook to read it.";
+        return mailboxUntrusted(out);
+      }
+      const full = await client2.get(path);
+      const bytes = full.ContentBytes;
+      if (typeof bytes !== "string" || bytes.length === 0) {
+        out.hint = "Outlook returned no content for this attachment.";
+        return mailboxUntrusted(out);
+      }
+      if (base64DecodedLength(bytes) > MAX_INLINE_BYTES) {
+        out.hint = "Content is not inlined above 5 MB. Open it in Outlook to read it.";
+        return mailboxUntrusted(out);
+      }
+      const buf = Buffer.from(bytes, "base64");
+      out.inlined = true;
+      if (image) {
+        const env = mailboxUntrusted(out);
+        return { ...env, content: [...env.content, ...imageResult(bytes, contentType).content] };
+      }
+      out.text = buf.subarray(0, utf8Boundary(buf, MAX_TEXT_BYTES)).toString("utf8");
+      if (buf.length > MAX_TEXT_BYTES) out.textTruncated = true;
+      return mailboxUntrusted(out);
+    }
+  );
 }
 
 // src/tools/calendar.ts
@@ -49153,7 +49438,7 @@ async function mailboxTimeZone(client2, opts = {}) {
 }
 
 // src/tools/calendar.ts
-var EVENT_SELECT = "Id,Subject,Start,End,Location,Organizer,IsAllDay,IsCancelled,ShowAs,OnlineMeetingUrl,OnlineMeeting,BodyPreview";
+var EVENT_SELECT = "Id,Subject,Start,End,Location,Organizer,IsAllDay,IsCancelled,ShowAs,OnlineMeetingUrl,OnlineMeeting,BodyPreview,IsOrganizer,ResponseStatus,ResponseRequested,Type,SeriesMasterId";
 function dateTimeTimeZone(value, zone) {
   if (/(Z|[+-]\d{2}:?\d{2})$/i.test(value)) {
     const d = new Date(value);
@@ -49258,12 +49543,13 @@ function registerCalendarTools(server, client2) {
   server.registerTool(
     "outlook_find_meeting_times",
     {
-      description: "Find times when people can meet \u2014 Outlook's Scheduling Assistant. Give the attendees, a search window and a duration; Outlook checks everyone's free/busy (and the signed-in user's, as organizer) and returns ranked candidate slots with each attendee's availability. By default only working hours are searched. Use this to answer \"when can X and Y meet?\"; then book with outlook_create_event. `start`/`end` are local wall-clock times in `timeZone` (default: the mailbox zone), and returned slots are in that zone too. " + UNTRUSTED_DESCRIPTION_SUFFIX,
+      description: "Find times when people can meet \u2014 Outlook's Scheduling Assistant. Give the attendees, a search window and a duration; Outlook checks everyone's free/busy (and the signed-in user's, as organizer) and returns ranked candidate slots with each attendee's availability. By default only working hours are searched. Use this to answer \"when can X and Y meet?\"; then book with outlook_create_event \u2014 each suggestion carries `createEventArgs` (times, zone and attendees; `subject` too when given here) to pass to it as-is. `start`/`end` are local wall-clock times in `timeZone` (default: the mailbox zone), and returned slots are in that zone too. view: 'raw' returns Outlook's response as-is, without `createEventArgs`. " + UNTRUSTED_DESCRIPTION_SUFFIX,
       annotations: { readOnlyHint: true, openWorldHint: true },
       inputSchema: external_exports.object({
         view: viewParam(VIEWS2),
         attendees: attendeeList("required attendees").min(1),
         optionalAttendees: attendeeList("optional attendees").optional(),
+        subject: external_exports.string().optional().describe("Meeting title, carried into each suggestion's createEventArgs; not sent to Outlook"),
         start: external_exports.string().min(1).describe("Earliest the meeting may start, e.g. 2026-10-12T09:00:00"),
         end: external_exports.string().min(1).describe("Latest the meeting may end, e.g. 2026-10-16T17:00:00"),
         durationMinutes: external_exports.number().int().min(5).max(1440).describe("Meeting length in minutes"),
@@ -49299,19 +49585,37 @@ function registerCalendarTools(server, client2) {
       };
       const data = await client2.post("/me/findmeetingtimes", body, { prefer: `outlook.timezone="${zone}"` });
       if (resolveView(args.view, VIEWS2) === "raw") return mailboxUntrusted(data);
-      const suggestions = (data?.MeetingTimeSuggestions ?? []).map((s) => ({
-        Start: trimTime(s.MeetingTimeSlot?.Start?.DateTime),
-        End: trimTime(s.MeetingTimeSlot?.End?.DateTime),
-        Confidence: s.Confidence,
-        Organizer: s.OrganizerAvailability,
-        Attendees: Object.fromEntries(
-          (s.AttendeeAvailability ?? []).map((a) => [
-            a.Attendee?.EmailAddress?.Address ?? a.Attendee?.EmailAddress?.Name ?? "?",
-            a.Availability
-          ])
-        ),
-        Reason: s.SuggestionReason
-      }));
+      const suggestions = (data?.MeetingTimeSuggestions ?? []).map((s) => {
+        const start = trimTime(s.MeetingTimeSlot?.Start?.DateTime);
+        const end = trimTime(s.MeetingTimeSlot?.End?.DateTime);
+        return {
+          Start: start,
+          End: end,
+          Confidence: s.Confidence,
+          Organizer: s.OrganizerAvailability,
+          Attendees: Object.fromEntries(
+            (s.AttendeeAvailability ?? []).map((a) => [
+              a.Attendee?.EmailAddress?.Address ?? a.Attendee?.EmailAddress?.Name ?? "?",
+              a.Availability
+            ])
+          ),
+          Reason: s.SuggestionReason,
+          // outlook_create_event's input for this slot, so booking it is a
+          // straight hand-off. The slot came back in `zone` (the Prefer header),
+          // which is also the zone create reads wall-clock times in. A slot
+          // without times cannot be booked, so it gets no args.
+          ...start && end ? {
+            createEventArgs: {
+              ...args.subject !== void 0 ? { subject: args.subject } : {},
+              start,
+              end,
+              timeZone: zone,
+              attendees: args.attendees,
+              ...args.optionalAttendees?.length ? { optionalAttendees: args.optionalAttendees } : {}
+            }
+          } : {}
+        };
+      });
       return mailboxUntrusted({
         timeZone: zone,
         count: suggestions.length,
@@ -49478,6 +49782,21 @@ function registerDirectoryTools(server, client2) {
       return minifiedResult(collection(data, resolveView(view, VIEWS2) === "raw"));
     }
   );
+  server.registerTool(
+    "outlook_list_categories",
+    {
+      description: "List the mailbox's categories (the master list) with their colours \u2014 the names outlook_update_message can add or remove.",
+      annotations: { readOnlyHint: true, openWorldHint: true },
+      inputSchema: external_exports.object({})
+    },
+    async () => {
+      const data = await client2.get(
+        "/me/outlook/masterCategories"
+      );
+      const categories = (data?.value ?? []).map((c) => ({ name: c.DisplayName, color: c.Color }));
+      return minifiedResult({ count: categories.length, categories });
+    }
+  );
 }
 
 // src/tools/writes.ts
@@ -49530,9 +49849,72 @@ async function writeOrUnknown(run, checkWhere) {
     };
   }
 }
+var INVITE_EVENT_SELECT = "Id,Subject,IsOrganizer,IsCancelled,Start,End,Organizer,ResponseStatus";
+var DELETE_EVENT_SELECT = "Id,Subject,IsOrganizer,IsCancelled,ResponseStatus,Type,SeriesMasterId,Start,End,Organizer,Attendees";
+var INVITE_RESPONSES = {
+  accept: { verb: "accept", status: "Accepted" },
+  tentative: { verb: "tentativelyaccept", status: "TentativelyAccepted" },
+  decline: { verb: "decline", status: "Declined" }
+};
 var naiveMs = (dt) => Date.parse(`${dt.replace(/\.\d+$/, "")}Z`);
 var fromNaiveMs = (ms) => new Date(ms).toISOString().replace(/\.\d{3}Z$/, "");
 var trimTime2 = (dt) => dt?.replace(/\.\d+$/, "");
+var REPLY_MODES = {
+  reply: { send: "reply", draft: "createreply", prefix: "RE: " },
+  replyAll: { send: "replyall", draft: "createreplyall", prefix: "RE: " },
+  forward: { send: "forward", draft: "createforward", prefix: "FW: " }
+};
+function addresses(...lists) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const a of lists.flat()) {
+    const v = a?.EmailAddress?.Address;
+    if (v && !seen.has(v.toLowerCase())) seen.set(v.toLowerCase(), v);
+  }
+  return [...seen.values()];
+}
+var escapeHtml = (t) => t.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+function bodyWithComment(body, comment) {
+  const existing = body?.Content ?? "";
+  if (body?.ContentType?.toLowerCase() !== "html") {
+    return { ContentType: "Text", Content: existing ? `${comment}
+
+${existing}` : comment };
+  }
+  const block = `<div>${escapeHtml(comment).replace(/\r?\n/g, "<br>")}</div><br>`;
+  const open2 = /<body[^>]*>/i.exec(existing);
+  const Content = open2 ? existing.slice(0, open2.index + open2[0].length) + block + existing.slice(open2.index + open2[0].length) : block + existing;
+  return { ContentType: "HTML", Content };
+}
+var FLAG_STATUS = { flagged: "Flagged", complete: "Complete", none: "NotFlagged" };
+var UPDATE_CONCURRENCY = 4;
+var sameCategories = (a, b) => [...a ?? []].map((c) => c.toLowerCase()).sort().join("\n") === [...b ?? []].map((c) => c.toLowerCase()).sort().join("\n");
+function editCategories(current, add, remove) {
+  const gone = new Set(remove.map((c) => c.toLowerCase()));
+  const next = (current ?? []).filter((c) => !gone.has(c.toLowerCase()));
+  for (const c of add) {
+    if (!next.some((n) => n.toLowerCase() === c.toLowerCase())) next.push(c);
+  }
+  return next;
+}
+function unchangedFields(payload, after) {
+  const out = [];
+  if (payload.IsRead !== void 0 && after.IsRead !== payload.IsRead) out.push("IsRead");
+  if (payload.Flag && after.Flag?.FlagStatus !== payload.Flag.FlagStatus) out.push("Flag");
+  if (payload.Categories && !sameCategories(after.Categories, payload.Categories)) out.push("Categories");
+  return out;
+}
+var createEventInput = external_exports.object({
+  subject: external_exports.string().describe("Event title"),
+  start: external_exports.string().min(1).describe("Start, ISO 8601 local time e.g. 2026-09-22T15:00:00"),
+  end: external_exports.string().min(1).describe("End, ISO 8601 local time"),
+  timeZone: external_exports.string().optional().describe("Windows time-zone name. Defaults to the MAILBOX time zone."),
+  location: external_exports.string().optional().describe("Location display name"),
+  body: external_exports.string().optional().describe("Event description"),
+  attendees: recipientList.describe("Required attendees' email addresses"),
+  optionalAttendees: recipientList.describe("Optional attendees' email addresses"),
+  teamsMeeting: teamsMeetingParam,
+  confirmToken: confirmTokenParam
+});
 function registerWriteTools(server, client2) {
   server.registerTool(
     "outlook_send_mail",
@@ -49651,6 +50033,85 @@ function registerWriteTools(server, client2) {
       });
     }
   );
+  server.registerTool(
+    "outlook_update_message",
+    {
+      description: 'Flag, categorise and/or mark read up to 50 messages at once \u2014 the filing step of the triage loop (outlook_get_unread \u2192 act \u2192 update). `flag`: "flagged", "complete" or "none". `categories` replaces a message\'s categories; `addCategories`/`removeCategories` edit each message\'s current list instead (names from outlook_list_categories). Duplicate ids are collapsed, so each message is written once. Each id gets its own result `{ id, ok, error? }`, verified against what Outlook stored; one failure does not stop the rest, but a rejected or missing credential fails the whole call. Only your mailbox changes \u2014 nobody is notified. ' + CONFIRM_FLOW_SENTENCE,
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+      inputSchema: external_exports.object({
+        messageIds: external_exports.array(external_exports.string().min(1)).min(1).max(50).describe("Message Ids (1 to 50)"),
+        flag: external_exports.enum(["flagged", "complete", "none"]).optional().describe("Follow-up flag to set"),
+        categories: external_exports.array(external_exports.string().min(1)).optional().describe("Replace the categories with exactly these ([] clears them)"),
+        addCategories: external_exports.array(external_exports.string().min(1)).optional().describe("Categories to add"),
+        removeCategories: external_exports.array(external_exports.string().min(1)).optional().describe("Categories to remove"),
+        isRead: external_exports.boolean().optional().describe("true to mark read, false to mark unread"),
+        confirmToken: confirmTokenParam
+      })
+    },
+    async ({ messageIds, flag, categories, addCategories, removeCategories, isRead, confirmToken }, ctx) => {
+      const add = addCategories ?? [];
+      const remove = removeCategories ?? [];
+      const editing = add.length > 0 || remove.length > 0;
+      if (categories !== void 0 && editing) {
+        throw new McpToolError("Pass `categories` or `addCategories`/`removeCategories`, not both.", {
+          hint: "`categories` replaces the whole list; the add/remove pair edits the current one."
+        });
+      }
+      const fixed = {
+        ...isRead !== void 0 ? { IsRead: isRead } : {},
+        ...flag ? { Flag: { FlagStatus: FLAG_STATUS[flag] } } : {},
+        ...categories !== void 0 ? { Categories: categories } : {}
+      };
+      if (Object.keys(fixed).length === 0 && !editing) {
+        throw new McpToolError("Nothing to update.", {
+          hint: "Pass at least one of flag, isRead, categories, addCategories or removeCategories."
+        });
+      }
+      const ids = [...new Set(messageIds)];
+      const pathOf = (id) => `/me/messages/${encodeURIComponent(id)}`;
+      const changes = [
+        ...flag ? [`flag ${flag}`] : [],
+        ...isRead !== void 0 ? [isRead ? "mark read" : "mark unread"] : [],
+        ...categories !== void 0 ? [`set categories [${categories.join(", ")}]`] : [],
+        ...add.length ? [`add categories [${add.join(", ")}]`] : [],
+        ...remove.length ? [`remove categories [${remove.join(", ")}]`] : []
+      ];
+      const gate = await confirmWrite(ctx, {
+        tool: "outlook_update_message",
+        action: "mail.update",
+        message: "Review and confirm this change:",
+        summary: `Update ${ids.length} message${ids.length === 1 ? "" : "s"}: ${changes.join("; ")}`,
+        // One signed-in mailbox per server process.
+        account: void 0,
+        target: ids.join(","),
+        request: {
+          method: "PATCH",
+          path: ids.length === 1 ? pathOf(ids[0]) : "/me/messages/{id}",
+          body: editing ? { ...fixed, Categories: `(each message's current categories${add.length ? ` + ${add.join(", ")}` : ""}${remove.length ? ` - ${remove.join(", ")}` : ""})` } : fixed
+        },
+        confirmToken
+      });
+      if (gate) return gate;
+      const results = await mapWithConcurrency(ids, UPDATE_CONCURRENCY, async (id) => {
+        try {
+          const payload = { ...fixed };
+          if (editing) {
+            const current = await client2.get(`${pathOf(id)}?$select=Categories`);
+            payload.Categories = editCategories(current?.Categories, add, remove);
+          }
+          const echoed = await client2.write("PATCH", pathOf(id), payload);
+          const after = echoed && typeof echoed === "object" ? echoed : await client2.get(`${pathOf(id)}?$select=IsRead,Flag,Categories`) ?? {};
+          const unchanged = unchangedFields(payload, after);
+          return unchanged.length ? { id, ok: false, error: `Outlook accepted the write but these did not change: ${unchanged.join(", ")}.` } : { id, ok: true };
+        } catch (e) {
+          if (isCredentialFailure(e)) throw e;
+          return { id, ok: false, error: e instanceof Error ? e.message : String(e) };
+        }
+      });
+      const updated = results.filter((r) => r.ok).length;
+      return minifiedResult({ updated, failed: results.length - updated, results });
+    }
+  );
   server.registerTool(
     "outlook_move_message",
     {
@@ -49693,20 +50154,9 @@ function registerWriteTools(server, client2) {
   server.registerTool(
     "outlook_create_event",
     {
-      description: 'Create a calendar event or meeting. A Microsoft Teams meeting is attached by default (`teamsMeeting: false` to skip) and its join link is returned. `timeZone` takes a WINDOWS zone name such as "Eastern Standard Time", not an IANA name. Attendees are emailed an invitation. To pick a time first, use outlook_find_meeting_times. ' + CONFIRM_FLOW_SENTENCE + " " + TIMEOUT_SENTENCE + " " + CONFIRM_INJECTION_RULE,
+      description: 'Create a calendar event or meeting. A Microsoft Teams meeting is attached by default (`teamsMeeting: false` to skip) and its join link is returned. `timeZone` takes a WINDOWS zone name such as "Eastern Standard Time", not an IANA name. Attendees are emailed an invitation. To pick a time first, use outlook_find_meeting_times: each suggestion it returns carries `createEventArgs` that can be passed here as-is (add `subject` if the search did not set one). ' + CONFIRM_FLOW_SENTENCE + " " + TIMEOUT_SENTENCE + " " + CONFIRM_INJECTION_RULE,
       annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: true },
-      inputSchema: external_exports.object({
-        subject: external_exports.string().describe("Event title"),
-        start: external_exports.string().min(1).describe("Start, ISO 8601 local time e.g. 2026-09-22T15:00:00"),
-        end: external_exports.string().min(1).describe("End, ISO 8601 local time"),
-        timeZone: external_exports.string().optional().describe("Windows time-zone name. Defaults to the MAILBOX time zone."),
-        location: external_exports.string().optional().describe("Location display name"),
-        body: external_exports.string().optional().describe("Event description"),
-        attendees: recipientList.describe("Required attendees' email addresses"),
-        optionalAttendees: recipientList.describe("Optional attendees' email addresses"),
-        teamsMeeting: teamsMeetingParam,
-        confirmToken: confirmTokenParam
-      })
+      inputSchema: createEventInput
     },
     async ({ subject, start, end, timeZone, location, body, attendees, optionalAttendees, teamsMeeting, confirmToken }, ctx) => {
       const wantTeams = teamsMeeting !== false;
@@ -49874,6 +50324,282 @@ function registerWriteTools(server, client2) {
       });
     }
   );
+  server.registerTool(
+    "outlook_respond_to_invite",
+    {
+      description: "Accept, tentatively accept or decline a meeting invitation. Pass the invite's `messageId` (from outlook_get_unread, which marks it kind \"meetingRequest\") or the event's `eventId` \u2014 exactly one. The organizer is sent your response unless `sendResponse: false`, in which case only your calendar changes and no confirmation is asked. Cancelled meetings and meetings you organize are refused. The result is verified by re-reading the event's response status; a declined meeting may leave your calendar entirely. " + CONFIRM_FLOW_SENTENCE + " " + TIMEOUT_SENTENCE + " " + CONFIRM_INJECTION_RULE,
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+      inputSchema: external_exports.object({
+        messageId: external_exports.string().min(1).optional().describe("Id of the invite message (resolved to its event). Give this or eventId."),
+        eventId: external_exports.string().min(1).optional().describe("Event Id. Give this or messageId."),
+        response: external_exports.enum(["accept", "tentative", "decline"]).describe("Your answer"),
+        comment: external_exports.string().optional().describe("Note to the organizer sent with the response"),
+        sendResponse: external_exports.boolean().optional().describe("Tell the organizer (default true). false changes only your calendar."),
+        confirmToken: confirmTokenParam
+      })
+    },
+    async ({ messageId, eventId, response, comment, sendResponse, confirmToken }, ctx) => {
+      if (messageId === void 0 === (eventId === void 0)) {
+        throw new McpToolError("Pass exactly one of messageId or eventId.", {
+          hint: "messageId is the invite in your inbox; eventId is the meeting on your calendar."
+        });
+      }
+      let event;
+      if (messageId !== void 0) {
+        const msg = await client2.get(
+          `/me/messages/${encodeURIComponent(messageId)}`,
+          { query: { $select: `Id,${MEETING_MESSAGE_TYPE}`, $expand: EVENT_EXPAND } }
+        );
+        event = resolvedEvent(msg?.Event);
+        if (!event) {
+          if (isMeetingMessage(msg)) {
+            throw new McpToolError(
+              "This invite's meeting is no longer on your calendar (already declined, cancelled or deleted) \u2014 there is nothing to respond to.",
+              { hint: "Mark the invite read or file it; answering it again is not possible." }
+            );
+          }
+          throw new McpToolError("That message is not a meeting invite.", {
+            hint: 'Only messages outlook_get_unread marks kind "meetingRequest" carry an event to answer.'
+          });
+        }
+      } else {
+        event = await client2.get(
+          `/me/events/${encodeURIComponent(eventId)}?$select=${INVITE_EVENT_SELECT}`
+        );
+      }
+      const id = event?.Id ?? eventId;
+      if (event?.IsCancelled === true) {
+        throw new McpToolError("This meeting has been cancelled; there is nothing to respond to.", {
+          hint: "Remove it from your calendar with outlook_delete_event if it is still shown."
+        });
+      }
+      if (event?.IsOrganizer === true || event?.ResponseStatus?.Response === "Organizer") {
+        throw new McpToolError("You organize this meeting, so you cannot respond to it.", {
+          hint: "To change or call it off, use outlook_update_event or Outlook itself."
+        });
+      }
+      const { verb, status } = INVITE_RESPONSES[response];
+      const notify = sendResponse !== false;
+      if (!notify && comment) {
+        throw new McpToolError("A comment can only go with a response the organizer receives.", {
+          hint: "Drop the comment, or leave sendResponse at its default (true) so the organizer gets both."
+        });
+      }
+      const path = `/me/events/${encodeURIComponent(id)}/${verb}`;
+      const payload = { ...comment ? { Comment: comment } : {}, SendResponse: notify };
+      if (notify) {
+        const when = `${trimTime2(event?.Start?.DateTime) ?? "?"} to ${trimTime2(event?.End?.DateTime) ?? "?"}${event?.Start?.TimeZone ? ` (${event.Start.TimeZone})` : ""}`;
+        const organizer = event?.Organizer?.EmailAddress?.Address ?? "the organizer";
+        const gate = await confirmWrite(ctx, {
+          tool: "outlook_respond_to_invite",
+          action: "calendar.respond_to_invite",
+          message: "Review and confirm this response (the organizer is notified):",
+          summary: `${response === "tentative" ? "Tentatively accept" : response === "accept" ? "Accept" : "Decline"} "${event?.Subject ?? id}" ${when}, organized by ${organizer}` + (comment ? `, with comment: "${comment}"` : ""),
+          // One signed-in mailbox per server process.
+          account: void 0,
+          target: id,
+          request: { method: "POST", path, body: payload },
+          confirmToken
+        });
+        if (gate) return gate;
+      }
+      const write = await writeOrUnknown(
+        () => client2.write("POST", path, payload),
+        "the event's response (outlook_get_event)"
+      );
+      if (!write.ok) return write.result;
+      let after;
+      try {
+        after = await client2.get(
+          `/me/events/${encodeURIComponent(id)}?$select=ResponseStatus`
+        );
+      } catch (e) {
+        if (response === "decline" && errorStatusOf(e) === 404) {
+          return minifiedResult({
+            responded: true,
+            eventId: id,
+            response: status,
+            sentResponse: notify,
+            note: "The declined meeting is no longer on your calendar."
+          });
+        }
+        return minifiedResult({
+          responded: null,
+          eventId: id,
+          sentResponse: notify,
+          warning: `Outlook accepted the response but re-reading the event failed (${e instanceof Error ? e.message : String(e)}), so it is unverified.`
+        });
+      }
+      const got = after?.ResponseStatus?.Response;
+      return minifiedResult({
+        responded: got === status,
+        eventId: id,
+        response: got,
+        sentResponse: notify,
+        ...got === status ? {} : { warning: `Outlook accepted the response but the status did not change (still ${got ?? "unknown"}).` }
+      });
+    }
+  );
+  server.registerTool(
+    "outlook_delete_event",
+    {
+      description: `Delete a calendar event. An occurrence's id deletes only that occurrence; a series master's id (Type "SeriesMaster" in outlook_get_event) deletes the WHOLE series. Only the organizer can delete a meeting \u2014 for an invite you received, decline it with outlook_respond_to_invite instead (a meeting the organizer already cancelled can be removed here). Deleting a meeting that has attendees sends each of them a cancellation, so it is confirmed first; your own appointment with no attendees, or a cancelled meeting, is removed without asking because only your calendar changes. The result is verified by re-reading the event. ` + CONFIRM_FLOW_SENTENCE + " " + TIMEOUT_SENTENCE + " " + CONFIRM_INJECTION_RULE,
+      annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: true },
+      inputSchema: external_exports.object({
+        id: external_exports.string().min(1).describe("Event Id from outlook_list_events or outlook_get_event (an occurrence, or a series master)"),
+        confirmToken: confirmTokenParam
+      })
+    },
+    async ({ id, confirmToken }, ctx) => {
+      const path = `/me/events/${encodeURIComponent(id)}`;
+      const zone = await mailboxTimeZone(client2);
+      const event = await client2.get(
+        `${path}?$select=${DELETE_EVENT_SELECT}`,
+        zone ? { prefer: `outlook.timezone="${zone}"` } : {}
+      );
+      const organizer = event?.IsOrganizer === true || event?.ResponseStatus?.Response === "Organizer";
+      const cancelled = event?.IsCancelled === true;
+      if (!organizer && !cancelled) {
+        throw new McpToolError("Only the organizer can delete this meeting.", {
+          hint: 'You are an attendee: deleting your copy would not tell the organizer. To drop it, decline with outlook_respond_to_invite (response: "decline"), which also removes it from your calendar.'
+        });
+      }
+      const scope = event?.Type === "SeriesMaster" ? "the whole series (every occurrence)" : event?.Type === "Occurrence" || event?.Type === "Exception" ? "only this occurrence (the rest of the series stays)" : "this event";
+      const attendeeCount = event?.Attendees?.length ?? 0;
+      const notifies = organizer && !cancelled && attendeeCount > 0;
+      if (notifies) {
+        const when = `${trimTime2(event?.Start?.DateTime) ?? "?"} to ${trimTime2(event?.End?.DateTime) ?? "?"}${event?.Start?.TimeZone ? ` (${event.Start.TimeZone})` : ""}`;
+        const gate = await confirmWrite(ctx, {
+          tool: "outlook_delete_event",
+          action: "calendar.delete_event",
+          message: "Review and confirm this deletion (every attendee is sent a cancellation):",
+          summary: `Delete "${event?.Subject ?? id}" ${when} \u2014 ${scope}; ${attendeeCount} attendee${attendeeCount === 1 ? "" : "s"} will be sent a cancellation`,
+          // One signed-in mailbox per server process.
+          account: void 0,
+          target: id,
+          request: { method: "DELETE", path },
+          preview: { scope, attendees: attendeeCount },
+          confirmToken
+        });
+        if (gate) return gate;
+      }
+      const write = await writeOrUnknown(
+        () => client2.write("DELETE", path),
+        "the calendar (outlook_get_event)"
+      );
+      if (!write.ok) return write.result;
+      const base = { Id: id, Subject: event?.Subject, scope, cancellationSent: notifies };
+      let after;
+      try {
+        after = await client2.get(`${path}?$select=Id`);
+      } catch (e) {
+        if (errorStatusOf(e) === 404) return minifiedResult({ deleted: true, ...base });
+        return minifiedResult({
+          deleted: null,
+          ...base,
+          warning: `Outlook accepted the delete but re-reading the event failed (${e instanceof Error ? e.message : String(e)}), so it is unverified.`
+        });
+      }
+      return minifiedResult({
+        deleted: false,
+        ...base,
+        warning: `Outlook accepted the delete but the event is still on the calendar${after?.Id ? ` (${after.Id})` : ""}.`
+      });
+    }
+  );
+  server.registerTool(
+    "outlook_reply",
+    {
+      description: "Reply, reply-all or forward a message, with `comment` as your new text above the quoted original. Outlook picks the recipients for reply (the sender, or its Reply-To) and reply-all (sender plus the original To and Cc, minus you); a forward needs `to`. `draftOnly: true` leaves the reply in Drafts and returns its id, sending nothing and asking no confirmation; otherwise it is sent at once. " + CONFIRM_FLOW_SENTENCE + " The preview shows the recipients, subject and comment. " + TIMEOUT_SENTENCE + " " + CONFIRM_INJECTION_RULE + " " + UNTRUSTED_DESCRIPTION_SUFFIX,
+      annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: true },
+      inputSchema: external_exports.object({
+        messageId: external_exports.string().min(1).describe("Id of the message to answer or forward"),
+        mode: external_exports.enum(["reply", "replyAll", "forward"]).describe("reply (sender only), replyAll, or forward"),
+        comment: external_exports.string().describe("Your text, placed above the quoted original"),
+        to: recipientList.describe("Forward recipients' email addresses (forward only, required there)"),
+        draftOnly: external_exports.boolean().optional().describe("Save to Drafts instead of sending (default false)"),
+        confirmToken: confirmTokenParam
+      })
+    },
+    async ({ messageId, mode, comment, to, draftOnly, confirmToken }, ctx) => {
+      if (mode === "forward" && !to?.length) {
+        throw new McpToolError("A forward needs at least one recipient.", {
+          hint: "Pass `to` with the addresses to forward to."
+        });
+      }
+      if (mode !== "forward" && to?.length) {
+        throw new McpToolError("`to` applies only to a forward.", {
+          hint: 'A reply goes where Outlook computes; use mode "forward" to send it somewhere else, or outlook_send_mail.'
+        });
+      }
+      const { send, draft, prefix } = REPLY_MODES[mode];
+      const base = `/me/messages/${encodeURIComponent(messageId)}`;
+      const forwardTo = mode === "forward" ? { ToRecipients: toRecipients(to) } : {};
+      if (draftOnly === true) {
+        const create = await writeOrUnknown(
+          () => client2.write(
+            "POST",
+            `${base}/${draft}`,
+            {}
+          ),
+          "Drafts"
+        );
+        if (!create.ok) return create.result;
+        const created = create.value;
+        if (!created?.Id) {
+          throw new McpToolError("Outlook did not return the draft it created.", {
+            hint: "Check the Drafts folder before trying again."
+          });
+        }
+        try {
+          await client2.write("PATCH", `/me/messages/${encodeURIComponent(created.Id)}`, {
+            Body: bodyWithComment(created.Body, comment),
+            ...forwardTo
+          });
+        } catch (e) {
+          return minifiedResult({
+            drafted: true,
+            mode,
+            draftId: created.Id,
+            WebLink: created.WebLink,
+            warning: `The draft was created but adding your comment${mode === "forward" ? " and recipients" : ""} failed (${e instanceof Error ? e.message : String(e)}). Edit it in Drafts, or delete it before trying again.`
+          });
+        }
+        return minifiedResult({ drafted: true, mode, draftId: created.Id, WebLink: created.WebLink });
+      }
+      const orig = await client2.get(base, {
+        query: { $select: "Subject,From,ReplyTo,ToRecipients,CcRecipients" }
+      });
+      const sender = orig?.ReplyTo?.length ? orig.ReplyTo : orig?.From ? [orig.From] : [];
+      const recipients = mode === "forward" ? { to: to ?? [], cc: [] } : mode === "replyAll" ? { to: addresses(sender, orig?.ToRecipients), cc: addresses(orig?.CcRecipients) } : { to: addresses(sender), cc: [] };
+      const subject = `${prefix}${orig?.Subject ?? ""}`;
+      const path = `${base}/${send}`;
+      const payload = { Comment: comment, ...forwardTo };
+      const everyone = [...recipients.to, ...recipients.cc.map((c) => `cc ${c}`)];
+      const who = everyone.length > MAX_RECIPIENTS ? `${everyone.slice(0, MAX_RECIPIENTS).join(", ")} and ${(everyone.length - MAX_RECIPIENTS).toLocaleString("en-US")} more` : everyone.join(", ");
+      const gate = await confirmWrite(ctx, {
+        tool: "outlook_reply",
+        action: `mail.${send}`,
+        message: "Review and confirm this email before it is sent:",
+        summary: `${mode === "forward" ? "Forward" : mode === "replyAll" ? "Reply all" : "Reply"} "${subject}" to ${who || "(no recipients)"}${mode === "replyAll" ? " (Outlook leaves out your own address)" : ""}, with comment: "${comment}"`,
+        // One signed-in mailbox per server process.
+        account: void 0,
+        target: messageId,
+        request: { method: "POST", path, body: payload },
+        confirmToken
+      });
+      if (gate) return gate;
+      const sent = await writeOrUnknown(() => client2.write("POST", path, payload), "Sent Items");
+      if (!sent.ok) return sent.result;
+      return mailboxUntrusted({
+        sent: true,
+        mode,
+        subject,
+        ...cappedRecipients("to", recipients.to),
+        ...cappedRecipients("cc", recipients.cc)
+      });
+    }
+  );
 }
 
 // src/tools/healthcheck.ts