@marlinjai/email-mcp 1.9.0 → 1.10.1

package/dist/index.js

@@ -3396,8 +3396,8 @@ var require_utils = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path4) {
-      let input2 = path4;
+    function removeDotSegments(path5) {
+      let input2 = path5;
       const output2 = [];
       let nextSlash = -1;
       let len = 0;
@@ -3596,8 +3596,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path4, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path4 && path4 !== "/" ? path4 : void 0;
+        const [path5, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path5 && path5 !== "/" ? path5 : void 0;
         wsComponent.query = query;
         wsComponent.resourceName = void 0;
       }
@@ -7068,6 +7068,14 @@ function extractAttachments(payload) {
   }
   return attachments;
 }
+function threadingHeaders(headers) {
+  const picked = {};
+  for (const name of ["Message-ID", "In-Reply-To", "References"]) {
+    const value = getHeader(headers, name);
+    if (value) picked[name.toLowerCase()] = value;
+  }
+  return Object.keys(picked).length > 0 ? picked : void 0;
+}
 function mapGmailMessage(message, accountId) {
   const headers = message.payload?.headers || [];
   const labelIds = message.labelIds || [];
@@ -7102,6 +7110,7 @@ function mapGmailMessage(message, accountId) {
     snippet: message.snippet,
     attachments,
     labels: labelIds,
+    headers: threadingHeaders(headers),
     flags: {
       read: !labelIds.includes("UNREAD"),
       starred: labelIds.includes("STARRED"),
@@ -7358,7 +7367,7 @@ var init_adapter = __esm({
         const raw = await this.buildRaw(params);
         const res = await gmail.users.messages.send({
           userId: "me",
-          requestBody: { raw }
+          requestBody: { raw, ...this.threadFor(params) }
         });
         return {
           id: res.data.id || "",
@@ -7371,19 +7380,53 @@ var init_adapter = __esm({
         const res = await gmail.users.drafts.create({
           userId: "me",
           requestBody: {
-            message: { raw }
+            message: { raw, ...this.threadFor(params) }
           }
         });
         return { id: res.data.id || "" };
       }
-      async updateDraft(draftId, params) {
+      /**
+       * drafts.update replaces the whole message, so what the caller does not
+       * name would be lost: a reply draft would fall out of its thread and a
+       * draft's files would be dropped. So when the caller names no thread, the
+       * thread and the reply headers of the stored draft are carried over, and
+       * when the caller names no attachments, the stored draft's files are. A
+       * given list (an empty one included) replaces the files.
+       */
+      async updateDraft(draftId, update) {
         const gmail = this.ensureConnected();
+        let params = update;
+        const keepThread = update.threadId === void 0;
+        const keepFiles = update.attachments === void 0;
+        if (keepThread || keepFiles) {
+          const existing = await gmail.users.drafts.get({
+            userId: "me",
+            id: draftId,
+            // 'metadata' is ids, labels and headers, no body (drafts.get has no
+            // way to ask for single headers, so all of them come back). The parts
+            // that list the files only come with 'full'.
+            format: keepFiles ? "full" : "metadata"
+          });
+          const message = existing.data.message;
+          if (keepThread) {
+            const header = (name) => (message?.payload?.headers || []).find((h) => (h.name || "").toLowerCase() === name)?.value || void 0;
+            const inReplyTo = update.inReplyTo ?? header("in-reply-to");
+            const references = update.references ?? header("references")?.split(/\s+/).filter(Boolean);
+            if (message?.threadId && inReplyTo) {
+              params = { ...params, threadId: message.threadId, inReplyTo, references: references?.length ? references : [inReplyTo] };
+            }
+          }
+          if (keepFiles && message?.id) {
+            const stored = await this.storedAttachments(message.id, message.payload);
+            if (stored.length) params = { ...params, attachments: stored };
+          }
+        }
         const raw = await this.buildRaw(params);
         const res = await gmail.users.drafts.update({
           userId: "me",
           id: draftId,
           requestBody: {
-            message: { raw }
+            message: { raw, ...this.threadFor(params) }
           }
         });
         return { id: res.data.id || draftId };
@@ -7762,6 +7805,51 @@ var init_adapter = __esm({
         }
         await this.deleteBlockRule(ruleId);
       }
+      /**
+       * Gmail files a message into an existing thread only when the threadId
+       * comes with In-Reply-To and References headers and a subject (which has to
+       * match the thread's; the reply tool builds "Re: <original subject>"). A
+       * threadId without them is left out, and the message starts its own thread.
+       */
+      threadFor(params) {
+        const belongs = params.threadId && params.inReplyTo && params.references?.length && params.subject.trim();
+        return belongs ? { threadId: params.threadId } : {};
+      }
+      /**
+       * The files of a stored message, with their bytes: every part that has a
+       * file name, at any depth. Large files are referenced by an attachment id
+       * and fetched; small ones can come inline in the part. A fetch that fails
+       * is not swallowed: a draft update built on it would drop that file.
+       */
+      async storedAttachments(messageId, payload) {
+        const gmail = this.ensureConnected();
+        const files = [];
+        const html = (extractBody(payload).html || "").toLowerCase();
+        const visit = async (part) => {
+          if (!part) return;
+          const partHeader = (name) => (part.headers || []).find((h) => (h.name || "").toLowerCase() === name)?.value || "";
+          const contentId = partHeader("content-id").trim().replace(/^<|>$/g, "").toLowerCase();
+          const embedded = /^\s*inline/i.test(partHeader("content-disposition")) && contentId !== "" && html.includes(`cid:${contentId}`);
+          if (part.filename && !embedded) {
+            let data = part.body?.data;
+            if (!data && part.body?.attachmentId) {
+              const res = await gmail.users.messages.attachments.get({ userId: "me", messageId, id: part.body.attachmentId });
+              data = res.data.data;
+            }
+            if (data === void 0 || data === null) {
+              throw new Error(`Could not read the draft's attachment ${part.filename}; the draft was not changed.`);
+            }
+            files.push({
+              filename: part.filename,
+              content: Buffer.from(data, "base64url"),
+              contentType: part.mimeType || "application/octet-stream"
+            });
+          }
+          for (const child of part.parts || []) await visit(child);
+        };
+        await visit(payload);
+        return files;
+      }
       /**
        * Builds the base64url `raw` payload Gmail expects for send, draft create and
        * draft update: a full MIME message with a text part, an HTML part when one
@@ -8055,12 +8143,41 @@ var init_mapper2 = __esm({
 
 // src/providers/outlook/adapter.ts
 import { Client } from "@microsoft/microsoft-graph-client";
-var OutlookAdapter;
+function megabytes(bytes) {
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function assertOutlookAttachmentSizes(attachments) {
+  if (!attachments?.length) return;
+  const limit = megabytes(OUTLOOK_MAX_ATTACHMENT_BYTES);
+  for (const att of attachments) {
+    if (att.content.length > OUTLOOK_MAX_ATTACHMENT_BYTES) {
+      throw new Error(`Outlook accepts attachments up to ${limit} through email-mcp; ${att.filename} is ${megabytes(att.content.length)}. ${UPLOAD_SESSION_HINT}`);
+    }
+  }
+}
+function assertOutlookRequestSize(body) {
+  const bytes = Buffer.byteLength(JSON.stringify(body));
+  if (bytes > OUTLOOK_MAX_REQUEST_BYTES) {
+    throw new Error(
+      `Outlook accepts requests up to ${megabytes(OUTLOOK_MAX_REQUEST_BYTES)} through email-mcp; this message is ${megabytes(bytes)} once its attachments are base64-encoded. ${UPLOAD_SESSION_HINT}`
+    );
+  }
+}
+var toGraphAttachment, OUTLOOK_MAX_ATTACHMENT_BYTES, OUTLOOK_MAX_REQUEST_BYTES, UPLOAD_SESSION_HINT, OutlookAdapter;
 var init_adapter2 = __esm({
   "src/providers/outlook/adapter.ts"() {
     "use strict";
     init_types();
     init_mapper2();
+    toGraphAttachment = (att) => ({
+      "@odata.type": "#microsoft.graph.fileAttachment",
+      name: att.filename,
+      contentType: att.contentType,
+      contentBytes: att.content.toString("base64")
+    });
+    OUTLOOK_MAX_ATTACHMENT_BYTES = 3 * 1024 * 1024;
+    OUTLOOK_MAX_REQUEST_BYTES = 4 * 1024 * 1024;
+    UPLOAD_SESSION_HINT = "Larger files need an upload session, which email-mcp does not implement for Outlook yet.";
     OutlookAdapter = class _OutlookAdapter {
       providerType = ProviderType.Outlook;
       client = null;
@@ -8079,8 +8196,8 @@ var init_adapter2 = __esm({
           }
         });
         const originalApi = client.api.bind(client);
-        client.api = (path4) => {
-          return originalApi(path4).header("Prefer", 'IdType="ImmutableId"');
+        client.api = (path5) => {
+          return originalApi(path5).header("Prefer", 'IdType="ImmutableId"');
         };
         this.client = client;
       }
@@ -8200,31 +8317,125 @@ var init_adapter2 = __esm({
           meta: mapGraphAttachment(attachment)
         };
       }
+      /**
+       * Graph only threads a reply (conversationId, subject, quoted history)
+       * through the createReply flow: POST /me/messages and /me/sendMail always
+       * start a new conversation whatever In-Reply-To says. Build the reply draft,
+       * overlay our subject, body, recipients and attachments, and return its id.
+       * Note the body replaces Graph's pre-filled quoted history.
+       *
+       * Each attachment goes up in a request of its own, so the sizes are checked
+       * per file, and before createReply so that a file that is too big leaves no
+       * draft behind. A draft that cannot be filled is deleted again. (A draft
+       * whose send failed is kept, see `sendEmail`.)
+       */
+      async createReplyDraft(params, replyToId) {
+        const client = this.ensureClient();
+        assertOutlookAttachmentSizes(params.attachments);
+        const draft = await client.api(`/me/messages/${encodeURIComponent(replyToId)}/createReply`).post({});
+        try {
+          await this.fillReplyDraft(draft.id, params);
+        } catch (error48) {
+          throw await this.discardDraft(draft.id, error48);
+        }
+        return draft.id;
+      }
+      async fillReplyDraft(draftId, params) {
+        const client = this.ensureClient();
+        const toGraphRecipient = (c) => ({
+          emailAddress: { name: c.name, address: c.email }
+        });
+        const patch = {
+          // Always the caller's subject: Graph pre-fills its own "RE: ..." one.
+          subject: params.subject,
+          body: { contentType: params.body.html ? "html" : "text", content: params.body.html || params.body.text || "" }
+        };
+        if (params.to?.length) patch.toRecipients = params.to.map(toGraphRecipient);
+        if (params.cc !== void 0) patch.ccRecipients = params.cc.map(toGraphRecipient);
+        if (params.bcc !== void 0) patch.bccRecipients = params.bcc.map(toGraphRecipient);
+        await client.api(`/me/messages/${encodeURIComponent(draftId)}`).patch(patch);
+        for (const att of params.attachments ?? []) {
+          await client.api(`/me/messages/${encodeURIComponent(draftId)}/attachments`).post(toGraphAttachment(att));
+        }
+      }
+      /**
+       * Deletes a reply draft that could not be filled, so a failed reply leaves
+       * nothing half-built in Drafts. Returns the error to throw: the original
+       * one, or, when the delete fails as well, the original message with a note
+       * that the draft is still there.
+       */
+      async discardDraft(draftId, cause) {
+        try {
+          await this.ensureClient().api(`/me/messages/${encodeURIComponent(draftId)}`).delete();
+          return cause;
+        } catch (deleteError) {
+          const message = cause instanceof Error ? cause.message : String(cause);
+          return new Error(
+            `${message} (the reply draft ${draftId} could not be removed and was left in Drafts: ${deleteError?.message ?? deleteError})`,
+            { cause }
+          );
+        }
+      }
       async sendEmail(params) {
         const client = this.ensureClient();
+        if (params.replyToGraphId) {
+          const draftId = await this.createReplyDraft(params, params.replyToGraphId);
+          try {
+            await client.api(`/me/messages/${encodeURIComponent(draftId)}/send`).post({});
+          } catch (error48) {
+            throw new Error(
+              `${error48?.message ?? error48} (the reply was saved as draft ${draftId} in Drafts and was not confirmed as sent; check Sent Items before sending it again)`,
+              { cause: error48 }
+            );
+          }
+          return { id: draftId };
+        }
+        assertOutlookAttachmentSizes(params.attachments);
         const message = this.buildGraphMessage(params);
         const payload = { message };
         if (params.attachments?.length) {
-          payload.message.attachments = params.attachments.map((att) => ({
-            "@odata.type": "#microsoft.graph.fileAttachment",
-            name: att.filename,
-            contentType: att.contentType,
-            contentBytes: att.content.toString("base64")
-          }));
+          payload.message.attachments = params.attachments.map(toGraphAttachment);
         }
+        assertOutlookRequestSize(payload);
         await client.api("/me/sendMail").post(payload);
         return { id: `sent-${Date.now()}` };
       }
       async createDraft(params) {
         const client = this.ensureClient();
+        if (params.replyToGraphId) {
+          return { id: await this.createReplyDraft(params, params.replyToGraphId) };
+        }
+        assertOutlookAttachmentSizes(params.attachments);
         const message = this.buildGraphMessage(params);
+        if (params.attachments?.length) {
+          message.attachments = params.attachments.map(toGraphAttachment);
+        }
+        assertOutlookRequestSize(message);
         const result = await client.api("/me/messages").post(message);
         return { id: result.id };
       }
       async updateDraft(draftId, params) {
         const client = this.ensureClient();
+        assertOutlookAttachmentSizes(params.attachments);
         const message = this.buildGraphMessage(params);
         await client.api(`/me/messages/${encodeURIComponent(draftId)}`).patch(message);
+        if (params.attachments) {
+          const attachmentsPath = `/me/messages/${encodeURIComponent(draftId)}/attachments`;
+          const previousIds = [];
+          let page = await client.api(attachmentsPath).select("id").get();
+          for (; ; ) {
+            previousIds.push(...(page.value || []).map((att) => att.id));
+            const next = page["@odata.nextLink"];
+            if (!next) break;
+            page = await client.api(next).get();
+          }
+          for (const att of params.attachments) {
+            await client.api(attachmentsPath).post(toGraphAttachment(att));
+          }
+          for (const id of previousIds) {
+            await client.api(`${attachmentsPath}/${encodeURIComponent(id)}`).delete();
+          }
+        }
         return { id: draftId };
       }
       async listDrafts(limit, offset) {
@@ -8781,6 +8992,12 @@ function mapImapFolder(imapFolder) {
     unreadCount: imapFolder.status?.unseen
   };
 }
+function imapAttachmentId(att, index) {
+  return att.contentId || `att-${index}`;
+}
+function headerValue(line) {
+  return line.slice(line.indexOf(":") + 1).replace(/\r?\n[ \t]+/g, " ").trim();
+}
 function mapParsedEmail(parsed, folder, accountId, uid) {
   const mapContact = (addr) => ({
     name: addr.name || void 0,
@@ -8791,7 +9008,7 @@ function mapParsedEmail(parsed, folder, accountId, uid) {
     return addrs.value.map(mapContact);
   };
   const attachments = (parsed.attachments || []).map((att, i) => ({
-    id: att.contentId || `att-${i}`,
+    id: imapAttachmentId(att, i),
     filename: att.filename || `attachment-${i}`,
     contentType: att.contentType || "application/octet-stream",
     size: att.size || 0
@@ -8820,7 +9037,7 @@ function mapParsedEmail(parsed, folder, accountId, uid) {
       flagged: parsed.flags?.has("\\Flagged") || false,
       draft: parsed.flags?.has("\\Draft") || false
     },
-    headers: parsed.headerLines ? Object.fromEntries(parsed.headerLines.map((h) => [h.key, h.line])) : void 0
+    headers: parsed.headerLines ? Object.fromEntries(parsed.headerLines.map((h) => [h.key, headerValue(h.line)])) : void 0
   };
 }
 var SPECIAL_USE_MAP;
@@ -9248,7 +9465,7 @@ var init_adapter3 = __esm({
       }
       async getEmail(id, folder) {
         const client = await this.ensureConnected();
-        const targetFolder = folder || "INBOX";
+        const targetFolder = folder ? await this.resolveFolder(folder) : "INBOX";
         let lock;
         try {
           lock = await client.getMailboxLock(targetFolder);
@@ -9267,13 +9484,20 @@ var init_adapter3 = __esm({
           lock.release();
         }
       }
-      async getThread(threadId) {
+      /**
+       * IMAP has no thread object: the thread is the set of messages in ONE
+       * folder whose Message-ID, References or In-Reply-To name `threadId`.
+       * Messages of the same conversation in other folders (the own replies in
+       * Sent, for example) are not part of the result.
+       */
+      async getThread(threadId, sourceFolder) {
         const client = await this.ensureConnected();
+        const folder = sourceFolder ? await this.resolveFolder(sourceFolder) : "INBOX";
         let lock;
         try {
-          lock = await client.getMailboxLock("INBOX");
+          lock = await client.getMailboxLock(folder);
         } catch (error48) {
-          throw formatImapError(error48, 'Failed to open folder "INBOX"');
+          throw formatImapError(error48, `Failed to open folder "${folder}"`);
         }
         try {
           const searchResult = await client.search(
@@ -9281,13 +9505,13 @@ var init_adapter3 = __esm({
             { uid: true }
           );
           const uids = Array.isArray(searchResult) ? searchResult : [];
-          if (uids.length === 0) throw new Error(`Thread ${threadId} not found`);
+          if (uids.length === 0) throw new Error(`Thread ${threadId} not found in "${folder}"`);
           const messages = [];
           for await (const msg of client.fetch(uids, { source: true, uid: true, flags: true })) {
             if (!msg.source) continue;
             const parsed = await simpleParser(msg.source);
             parsed.flags = msg.flags;
-            messages.push(mapParsedEmail(parsed, "INBOX", this.accountId, msg.uid));
+            messages.push(mapParsedEmail(parsed, folder, this.accountId, msg.uid));
           }
           const participantMap = /* @__PURE__ */ new Map();
           for (const msg of messages) {
@@ -9309,27 +9533,29 @@ var init_adapter3 = __esm({
           lock.release();
         }
       }
-      async getAttachment(emailId, attachmentId) {
+      async getAttachment(emailId, attachmentId, sourceFolder) {
         const client = await this.ensureConnected();
+        const folder = sourceFolder ? await this.resolveFolder(sourceFolder) : "INBOX";
         let lock;
         try {
-          lock = await client.getMailboxLock("INBOX");
+          lock = await client.getMailboxLock(folder);
         } catch (error48) {
-          throw formatImapError(error48, 'Failed to open folder "INBOX"');
+          throw formatImapError(error48, `Failed to open folder "${folder}"`);
         }
         try {
           const msg = await client.fetchOne(String(emailId), { source: true, uid: true }, { uid: true });
-          if (!msg) throw new Error(`Email ${emailId} not found`);
+          if (!msg) throw new Error(`Email ${emailId} not found in "${folder}"`);
           if (!msg.source) throw new Error(`Email ${emailId} has no source`);
           const parsed = await simpleParser(msg.source);
-          const attachment = (parsed.attachments || []).find(
-            (att) => att.contentId === attachmentId || att.filename === attachmentId
-          );
-          if (!attachment) throw new Error(`Attachment ${attachmentId} not found in email ${emailId}`);
+          const attachments = parsed.attachments || [];
+          let index = attachments.findIndex((att, i) => imapAttachmentId(att, i) === attachmentId);
+          if (index === -1) index = attachments.findIndex((att) => att.filename === attachmentId);
+          if (index === -1) throw new Error(`Attachment ${attachmentId} not found in email ${emailId}`);
+          const attachment = attachments[index];
           return {
             data: attachment.content,
             meta: {
-              id: attachment.contentId || attachmentId,
+              id: imapAttachmentId(attachment, index),
               filename: attachment.filename || "attachment",
               contentType: attachment.contentType || "application/octet-stream",
               size: attachment.size || 0
@@ -9366,18 +9592,53 @@ var init_adapter3 = __esm({
        * Drafts folder, and IMAP messages are immutable once appended. This
        * deletes the old revision and appends a new one, so the returned `id`
        * is a NEW uid; the old id no longer resolves after this call.
+       *
+       * A reply draft keeps its place in the thread: when the caller passes no
+       * `inReplyTo`, the In-Reply-To and References headers of the old revision
+       * are copied into the new one. The same goes for files: when the caller
+       * passes no `attachments`, the old revision's attachments are copied over
+       * (a given list, an empty one included, replaces them). Images embedded in
+       * the old HTML body are not files and are not copied: the new body replaces
+       * the old one.
        */
       async updateDraft(draftId, params, sourceFolder) {
         const client = await this.ensureConnected();
         const draftsFolder = sourceFolder ? await this.resolveFolder(sourceFolder) : await this.resolveFolder("Drafts");
-        const rawMessage = await this.buildDraftMessage(params);
         let lock;
         try {
           lock = await client.getMailboxLock(draftsFolder);
         } catch (error48) {
           throw formatImapError(error48, `Failed to open folder "${draftsFolder}"`);
         }
+        let rawMessage;
         try {
+          let next = params;
+          const keepThread = params.inReplyTo === void 0;
+          const keepFiles = params.attachments === void 0;
+          if (keepThread || keepFiles) {
+            const old = await client.fetchOne(String(draftId), { source: true, uid: true }, { uid: true });
+            if (old && old.source) {
+              const parsed = await simpleParser(old.source);
+              if (keepThread && parsed.inReplyTo) {
+                const references = [].concat(parsed.references ?? []);
+                next = { ...next, inReplyTo: parsed.inReplyTo, references: params.references ?? references };
+              }
+              if (keepFiles) {
+                const html = (parsed.html || "").toLowerCase();
+                const files = (parsed.attachments || []).filter((att) => {
+                  if (!att.related) return true;
+                  const cid = String(att.cid || att.contentId || "").replace(/^<|>$/g, "").toLowerCase();
+                  return !cid || !html.includes(`cid:${cid}`);
+                }).map((att, i) => ({
+                  filename: att.filename || `attachment-${i + 1}`,
+                  content: att.content,
+                  contentType: att.contentType || "application/octet-stream"
+                }));
+                if (files.length) next = { ...next, attachments: files };
+              }
+            }
+          }
+          rawMessage = await this.buildDraftMessage(next);
           await client.messageDelete(draftId, { uid: true });
         } finally {
           lock.release();
@@ -9693,6 +9954,11 @@ var init_account_manager = __esm({
           connected: this.providers.has(c.id)
         }));
       }
+      /** The account's own address, or undefined for an unknown account id. */
+      async getAccountEmail(accountId) {
+        const creds = this.credentials.get(accountId) ?? await this.store.get(accountId);
+        return creds?.email;
+      }
       async getProvider(accountId) {
         const existing = this.providers.get(accountId);
         if (existing) {
@@ -10807,8 +11073,8 @@ function getErrorMap() {
 
 // node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path4, errorMaps, issueData } = params;
-  const fullPath = [...path4, ...issueData.path || []];
+  const { data, path: path5, errorMaps, issueData } = params;
+  const fullPath = [...path5, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -10923,11 +11189,11 @@ var errorUtil;
 
 // node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path4, key) {
+  constructor(parent, value, path5, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path4;
+    this._path = path5;
     this._key = key;
   }
   get path() {
@@ -14850,10 +15116,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path4) {
-  if (!path4)
+function getElementAtPath(obj, path5) {
+  if (!path5)
     return obj;
-  return path4.reduce((acc, key) => acc?.[key], obj);
+  return path5.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -15236,11 +15502,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path4, issues) {
+function prefixIssues(path5, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path4);
+    iss.path.unshift(path5);
     return iss;
   });
 }
@@ -15423,7 +15689,7 @@ function formatError(error48, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error48, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error49, path4 = []) => {
+  const processError = (error49, path5 = []) => {
     var _a2, _b;
     for (const issue2 of error49.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -15433,7 +15699,7 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path4, ...issue2.path];
+        const fullpath = [...path5, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -15465,8 +15731,8 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path4 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path4) {
+  const path5 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path5) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -27872,13 +28138,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path4 = ref.slice(1).split("/").filter(Boolean);
-  if (path4.length === 0) {
+  const path5 = ref.slice(1).split("/").filter(Boolean);
+  if (path5.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path4[0] === defsKey) {
-    const key = path4[1];
+  if (path5[0] === defsKey) {
+    const key = path5[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -33807,12 +34073,13 @@ function registerReadingTools(server, accountManager) {
     "Get a single email by ID",
     {
       accountId: external_exports3.string(),
-      emailId: external_exports3.string()
+      emailId: external_exports3.string(),
+      sourceFolder: external_exports3.string().optional().describe("Source folder (required for IMAP/iCloud when email is not in INBOX)")
     },
     async (args) => {
       try {
         const provider = await accountManager.getProvider(args.accountId);
-        const email3 = await provider.getEmail(args.emailId);
+        const email3 = await provider.getEmail(args.emailId, args.sourceFolder);
         return jsonResult2(email3);
       } catch (error48) {
         return jsonResult2({ error: error48.message });
@@ -33824,12 +34091,13 @@ function registerReadingTools(server, accountManager) {
     "Get an email thread by thread ID",
     {
       accountId: external_exports3.string(),
-      threadId: external_exports3.string()
+      threadId: external_exports3.string(),
+      sourceFolder: external_exports3.string().optional().describe("Folder to look for the thread in on IMAP/iCloud, where a thread is searched in one folder (default INBOX). Gmail and Outlook ignore it")
     },
     async (args) => {
       try {
         const provider = await accountManager.getProvider(args.accountId);
-        const thread = await provider.getThread(args.threadId);
+        const thread = await provider.getThread(args.threadId, args.sourceFolder);
         return jsonResult2(thread);
       } catch (error48) {
         return jsonResult2({ error: error48.message });
@@ -33842,12 +34110,13 @@ function registerReadingTools(server, accountManager) {
     {
       accountId: external_exports3.string(),
       emailId: external_exports3.string(),
-      attachmentId: external_exports3.string()
+      attachmentId: external_exports3.string(),
+      sourceFolder: external_exports3.string().optional().describe("Source folder (required for IMAP/iCloud when email is not in INBOX)")
     },
     async (args) => {
       try {
         const provider = await accountManager.getProvider(args.accountId);
-        const { data, meta: meta3 } = await provider.getAttachment(args.emailId, args.attachmentId);
+        const { data, meta: meta3 } = await provider.getAttachment(args.emailId, args.attachmentId, args.sourceFolder);
         return jsonResult2({
           data: Buffer.from(data).toString("base64"),
           meta: meta3
@@ -33864,13 +34133,14 @@ function registerReadingTools(server, accountManager) {
       accountId: external_exports3.string(),
       emailId: external_exports3.string(),
       attachmentId: external_exports3.string(),
-      outputPath: external_exports3.string().describe("Relative file path (within the downloads directory) to save the attachment as")
+      outputPath: external_exports3.string().describe("Relative file path (within the downloads directory) to save the attachment as"),
+      sourceFolder: external_exports3.string().optional().describe("Source folder (required for IMAP/iCloud when email is not in INBOX)")
     },
     async (args) => {
       try {
         const absPath = resolveDownloadPath(args.outputPath);
         const provider = await accountManager.getProvider(args.accountId);
-        const { data, meta: meta3 } = await provider.getAttachment(args.emailId, args.attachmentId);
+        const { data, meta: meta3 } = await provider.getAttachment(args.emailId, args.attachmentId, args.sourceFolder);
         fs3.mkdirSync(path3.dirname(absPath), { recursive: true, mode: 448 });
         fs3.writeFileSync(absPath, Buffer.from(data), { mode: 384 });
         fs3.chmodSync(absPath, 384);
@@ -33887,6 +34157,161 @@ function registerReadingTools(server, accountManager) {
   );
 }
 
+// src/tools/attachments.ts
+import { closeSync, constants as fsConstants, fstatSync, lstatSync, openSync, readFileSync, realpathSync, statSync } from "node:fs";
+import os4 from "node:os";
+import path4 from "node:path";
+var MAX_TOTAL_ATTACHMENT_BYTES = 25 * 1024 * 1024;
+var ATTACHMENTS_DIR_ENV = "EMAIL_MCP_ATTACHMENTS_DIR";
+var MIME_BY_EXT = {
+  ".pdf": "application/pdf",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".txt": "text/plain",
+  ".csv": "text/csv",
+  ".html": "text/html",
+  ".json": "application/json",
+  ".zip": "application/zip",
+  ".doc": "application/msword",
+  ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  ".xls": "application/vnd.ms-excel",
+  ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  ".ics": "text/calendar"
+};
+var AttachmentInputSchema = external_exports3.object({
+  path: external_exports3.string().optional().describe(
+    `A file inside the folder the user set in ${ATTACHMENTS_DIR_ENV}: its name, a path relative to that folder, or an absolute path inside it. Files anywhere else are refused, and path attachments are off when that variable is not set.`
+  ),
+  content: external_exports3.string().optional().describe("Base64-encoded file content, used instead of path"),
+  filename: external_exports3.string().optional().describe("File name shown to the recipient. Required with content; defaults to the file name of path"),
+  contentType: external_exports3.string().optional().describe("MIME type. Inferred from the file extension when omitted")
+}).describe("One attachment: give either path or content (base64) plus filename");
+var AttachmentsSchema = external_exports3.array(AttachmentInputSchema).optional().describe(`Files to attach. Total size is capped at ${MAX_TOTAL_ATTACHMENT_BYTES / (1024 * 1024)} MB`);
+function inferContentType(filename) {
+  return MIME_BY_EXT[path4.extname(filename).toLowerCase()] ?? "application/octet-stream";
+}
+function megabytes2(bytes) {
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function isInside(dir, target) {
+  const relative = path4.relative(dir, target);
+  return relative !== "" && !relative.startsWith("..") && !path4.isAbsolute(relative);
+}
+function attachmentsDir(env = process.env) {
+  const raw = (env[ATTACHMENTS_DIR_ENV] || "").trim();
+  if (!raw) return null;
+  const expanded = raw === "~" || raw.startsWith("~/") ? path4.join(os4.homedir(), raw.slice(1)) : raw;
+  return path4.resolve(expanded);
+}
+var HOW_TO_ALLOW = `Set ${ATTACHMENTS_DIR_ENV} to the one folder files may be attached from (in the environment of the email-mcp server, in the MCP client configuration), put the file there and restart the client. Content passed directly as base64 with a filename works without it.`;
+function planPath(input2, env, dataDir) {
+  const given = input2.path;
+  if (given.trim() === "") throw new Error("Attachment path is empty");
+  const dir = attachmentsDir(env);
+  if (!dir) {
+    throw new Error(`Attaching files by path is switched off: ${ATTACHMENTS_DIR_ENV} is not set. ${HOW_TO_ALLOW}`);
+  }
+  let dirReal;
+  try {
+    dirReal = realpathSync(dir);
+    if (!statSync(dirReal).isDirectory()) throw new Error("not a directory");
+  } catch {
+    throw new Error(`The attachments folder ${dir} (${ATTACHMENTS_DIR_ENV}) does not exist or is not a folder.`);
+  }
+  const candidate = path4.resolve(dir, given);
+  if (!isInside(dir, candidate) && !isInside(dirReal, candidate)) {
+    throw new Error(`Only files inside ${dir} can be attached (${ATTACHMENTS_DIR_ENV}). Put the file there and pass its name.`);
+  }
+  let real;
+  try {
+    real = realpathSync(candidate);
+  } catch {
+    throw new Error(`No such file in the attachments folder: ${path4.relative(dir, candidate)}`);
+  }
+  if (!isInside(dirReal, real)) {
+    throw new Error(`Only files inside ${dir} can be attached (${ATTACHMENTS_DIR_ENV}); ${path4.relative(dir, candidate)} points outside it.`);
+  }
+  let ownDir = null;
+  try {
+    ownDir = realpathSync(dataDir);
+  } catch {
+    ownDir = null;
+  }
+  if (ownDir && path4.dirname(real) === ownDir) {
+    throw new Error("Files in the email-mcp data folder itself cannot be attached.");
+  }
+  const stat = lstatSync(real);
+  if (!stat.isFile()) {
+    throw new Error(`Not a file: ${path4.relative(dir, candidate)}`);
+  }
+  const filename = input2.filename ?? path4.basename(real);
+  return {
+    bytes: stat.size,
+    load: () => ({
+      filename,
+      content: readValidatedFile(real, stat, path4.relative(dir, candidate)),
+      contentType: input2.contentType ?? inferContentType(filename)
+    })
+  };
+}
+function readValidatedFile(real, validated, display) {
+  let fd;
+  try {
+    fd = openSync(real, fsConstants.O_RDONLY | (fsConstants.O_NOFOLLOW ?? 0));
+  } catch {
+    throw new Error(`${display} changed while it was being attached; try again.`);
+  }
+  try {
+    const opened = fstatSync(fd);
+    if (!opened.isFile() || opened.dev !== validated.dev || opened.ino !== validated.ino) {
+      throw new Error(`${display} changed while it was being attached; try again.`);
+    }
+    return readFileSync(fd);
+  } finally {
+    closeSync(fd);
+  }
+}
+function planContent(input2) {
+  if (!input2.filename) throw new Error("Attachment with content requires a filename");
+  const filename = input2.filename;
+  const compact = input2.content.replace(/\s+/g, "");
+  if (compact === "") throw new Error(`Attachment ${filename} has empty content`);
+  if (!/^[A-Za-z0-9+/]*={0,2}$/.test(compact) || compact.length % 4 === 1) {
+    throw new Error(`Attachment ${filename}: content is not valid base64`);
+  }
+  const padding = compact.endsWith("==") ? 2 : compact.endsWith("=") ? 1 : 0;
+  return {
+    bytes: Math.floor(compact.length * 3 / 4) - padding,
+    load: () => ({
+      filename,
+      content: Buffer.from(compact, "base64"),
+      contentType: input2.contentType ?? inferContentType(filename)
+    })
+  };
+}
+function plan(input2, env, dataDir) {
+  const hasPath = input2.path !== void 0;
+  const hasContent = input2.content !== void 0;
+  if (hasPath && hasContent) throw new Error("Attachment must have either path or content, not both");
+  if (hasPath) return planPath(input2, env, dataDir);
+  if (hasContent) return planContent(input2);
+  throw new Error("Attachment needs a path or content");
+}
+function resolveAttachments(inputs, env = process.env, dataDir = path4.join(os4.homedir(), ".email-mcp")) {
+  if (inputs === void 0) return void 0;
+  const planned = inputs.map((input2) => plan(input2, env, dataDir));
+  assertAttachmentTotal(planned.reduce((sum, p) => sum + p.bytes, 0));
+  return planned.map((p) => p.load());
+}
+function assertAttachmentTotal(totalBytes) {
+  if (totalBytes > MAX_TOTAL_ATTACHMENT_BYTES) {
+    throw new Error(`Attachments total ${megabytes2(totalBytes)}, over the ${megabytes2(MAX_TOTAL_ATTACHMENT_BYTES)} limit`);
+  }
+}
+
 // src/tools/sending.ts
 var ContactSchema = external_exports3.object({
   email: external_exports3.string(),
@@ -33899,6 +34324,31 @@ var BodySchema = external_exports3.object({
 function jsonResult3(data) {
   return { content: [{ type: "text", text: JSON.stringify(data) }] };
 }
+function messageIds(headerValue2) {
+  return headerValue2?.match(/<[^<>\s]+>/g) ?? [];
+}
+function replyThreading(original) {
+  const [messageId] = messageIds(original.headers?.["message-id"]);
+  if (!messageId) return { threadId: original.threadId, replyToGraphId: original.id };
+  const earlier = messageIds(original.headers?.["references"]).filter((id) => id !== messageId);
+  return {
+    inReplyTo: messageId,
+    references: [...earlier, messageId],
+    threadId: original.threadId,
+    replyToGraphId: original.id
+  };
+}
+var sameAddress = (a, b) => a.toLowerCase() === b.toLowerCase();
+function withoutDuplicates(to, cc) {
+  const seen = /* @__PURE__ */ new Set();
+  const firstMention = (c) => {
+    const key = c.email.toLowerCase();
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  };
+  return { to: to.filter(firstMention), cc: cc?.filter(firstMention) };
+}
 function registerSendingTools(server, accountManager) {
   server.tool(
     "email_send",
@@ -33909,7 +34359,8 @@ function registerSendingTools(server, accountManager) {
       cc: external_exports3.array(ContactSchema).optional(),
       bcc: external_exports3.array(ContactSchema).optional(),
       subject: external_exports3.string(),
-      body: BodySchema
+      body: BodySchema,
+      attachments: AttachmentsSchema
     },
     async (args) => {
       try {
@@ -33919,7 +34370,8 @@ function registerSendingTools(server, accountManager) {
           cc: args.cc,
           bcc: args.bcc,
           subject: args.subject,
-          body: args.body
+          body: args.body,
+          attachments: resolveAttachments(args.attachments)
         };
         const result = await provider.sendEmail(params);
         return jsonResult3(result);
@@ -33930,32 +34382,53 @@ function registerSendingTools(server, accountManager) {
   );
   server.tool(
     "email_reply",
-    "Reply to an existing email",
+    "Reply to an existing email, in its thread. With replyAll the reply goes to the original sender and all To and Cc recipients, except the account's own address",
     {
       accountId: external_exports3.string(),
       emailId: external_exports3.string(),
+      sourceFolder: external_exports3.string().optional().describe("Source folder (required for IMAP/iCloud when email is not in INBOX)"),
       body: BodySchema,
-      replyAll: external_exports3.boolean().optional()
+      replyAll: external_exports3.boolean().optional(),
+      to: external_exports3.array(ContactSchema).optional().describe("Replace the default To (the original sender). Use it when the original was sent by you, so the reply goes to the real correspondents instead of back to yourself"),
+      cc: external_exports3.array(ContactSchema).optional().describe("Cc recipients. Replaces any Cc carried over by replyAll"),
+      bcc: external_exports3.array(ContactSchema).optional(),
+      additionalRecipients: external_exports3.array(ContactSchema).optional().describe("Extra To recipients added to the default or given To (deduplicated by address)"),
+      attachments: AttachmentsSchema
     },
     async (args) => {
       try {
         const provider = await accountManager.getProvider(args.accountId);
-        const original = await provider.getEmail(args.emailId);
-        const messageId = original.headers?.["message-id"] ?? original.id;
+        const original = await provider.getEmail(args.emailId, args.sourceFolder);
         const subject = original.subject.startsWith("Re: ") ? original.subject : `Re: ${original.subject}`;
         let to = [original.from];
         let cc;
         if (args.replyAll) {
-          to = [original.from, ...original.to];
-          cc = original.cc;
+          const own = await accountManager.getAccountEmail(args.accountId);
+          const others = (c) => !own || !sameAddress(c.email, own);
+          to = [original.from, ...original.to].filter(others);
+          if (to.length === 0) to = [original.from];
+          cc = original.cc?.filter(others);
+        }
+        if (args.to?.length) to = args.to;
+        if (args.additionalRecipients?.length) {
+          const seen = new Set(to.map((c) => c.email.toLowerCase()));
+          for (const r of args.additionalRecipients) {
+            if (!seen.has(r.email.toLowerCase())) {
+              to = [...to, r];
+              seen.add(r.email.toLowerCase());
+            }
+          }
         }
+        if (args.cc !== void 0) cc = args.cc;
+        if (args.replyAll) ({ to, cc } = withoutDuplicates(to, cc));
         const params = {
           to,
           cc,
+          bcc: args.bcc,
           subject,
           body: args.body,
-          inReplyTo: messageId,
-          references: [messageId]
+          ...replyThreading(original),
+          attachments: resolveAttachments(args.attachments)
         };
         const result = await provider.sendEmail(params);
         return jsonResult3(result);
@@ -33966,17 +34439,22 @@ function registerSendingTools(server, accountManager) {
   );
   server.tool(
     "email_forward",
-    "Forward an email to new recipients",
+    "Forward an email to new recipients. The original message's attachments are left out unless includeOriginalAttachments is true",
     {
       accountId: external_exports3.string(),
       emailId: external_exports3.string(),
       to: external_exports3.array(ContactSchema),
-      body: BodySchema.optional()
+      cc: external_exports3.array(ContactSchema).optional(),
+      bcc: external_exports3.array(ContactSchema).optional(),
+      body: BodySchema.optional(),
+      attachments: AttachmentsSchema.describe("Files to attach to the forward. Total size, together with forwarded original attachments, is capped at 25 MB"),
+      includeOriginalAttachments: external_exports3.boolean().optional().describe("Also forward the original message's attachments (default false). Leave it off unless the user asked for the files to go along"),
+      sourceFolder: external_exports3.string().optional().describe("Source folder (required for IMAP/iCloud when email is not in INBOX)")
     },
     async (args) => {
       try {
         const provider = await accountManager.getProvider(args.accountId);
-        const original = await provider.getEmail(args.emailId);
+        const original = await provider.getEmail(args.emailId, args.sourceFolder);
         const subject = original.subject.startsWith("Fwd: ") ? original.subject : `Fwd: ${original.subject}`;
         const forwardHeader = [
           "---------- Forwarded message ----------",
@@ -34010,10 +34488,27 @@ function registerSendingTools(server, accountManager) {
             originalHtml
           ].join("");
         }
+        const extra = resolveAttachments(args.attachments) ?? [];
+        const forwarded = [];
+        if (args.includeOriginalAttachments && original.attachments?.length) {
+          const extraBytes = extra.reduce((sum, a) => sum + a.content.length, 0);
+          assertAttachmentTotal(extraBytes + original.attachments.reduce((sum, a) => sum + (a.size || 0), 0));
+          let bytes = extraBytes;
+          for (const att of original.attachments) {
+            const fetched = await provider.getAttachment(original.id, att.id, args.sourceFolder);
+            bytes += fetched.data.length;
+            assertAttachmentTotal(bytes);
+            forwarded.push({ filename: att.filename, content: fetched.data, contentType: att.contentType });
+          }
+        }
+        const attachments = [...forwarded, ...extra];
         const params = {
           to: args.to,
+          cc: args.cc,
+          bcc: args.bcc,
           subject,
-          body: { text: forwardedText, html: forwardedHtml }
+          body: { text: forwardedText, html: forwardedHtml },
+          attachments: attachments.length ? attachments : void 0
         };
         const result = await provider.sendEmail(params);
         return jsonResult3(result);
@@ -34024,12 +34519,15 @@ function registerSendingTools(server, accountManager) {
   );
   server.tool(
     "email_draft_create",
-    "Create a new email draft",
+    "Create a new email draft. Pass inReplyToEmailId to save it as a reply in that message's thread",
     {
       accountId: external_exports3.string(),
       to: external_exports3.array(ContactSchema),
       subject: external_exports3.string(),
-      body: BodySchema
+      body: BodySchema,
+      attachments: AttachmentsSchema,
+      inReplyToEmailId: external_exports3.string().optional().describe("Id of the email this draft replies to. The draft joins that thread (Gmail threadId, Outlook createReply, In-Reply-To/References headers elsewhere)"),
+      inReplyToSourceFolder: external_exports3.string().optional().describe("Folder of the email named in inReplyToEmailId (required for IMAP/iCloud when that email is not in INBOX). The draft itself is saved to Drafts")
     },
     async (args) => {
       try {
@@ -34037,8 +34535,12 @@ function registerSendingTools(server, accountManager) {
         const params = {
           to: args.to,
           subject: args.subject,
-          body: args.body
+          body: args.body,
+          attachments: resolveAttachments(args.attachments)
         };
+        if (args.inReplyToEmailId) {
+          Object.assign(params, replyThreading(await provider.getEmail(args.inReplyToEmailId, args.inReplyToSourceFolder)));
+        }
         const result = await provider.createDraft(params);
         return jsonResult3(result);
       } catch (error48) {
@@ -34048,13 +34550,16 @@ function registerSendingTools(server, accountManager) {
   );
   server.tool(
     "email_draft_update",
-    "Update an existing email draft in place (to/subject/body). On Gmail and Outlook the draft id is unchanged. On iCloud/generic IMAP there is no in-place update \u2014 the old draft is deleted and a new one appended \u2014 so the returned id is a NEW id and the old one no longer resolves; always use the id this call returns, not the one you passed in.",
+    "Update an existing email draft in place (to/subject/body). A reply draft stays in its thread. On Gmail and Outlook the draft id is unchanged. On iCloud/generic IMAP there is no in-place update (the old draft is deleted and a new one appended), so the returned id is a NEW id and the old one no longer resolves; always use the id this call returns, not the one you passed in.",
     {
       accountId: external_exports3.string(),
       draftId: external_exports3.string(),
       to: external_exports3.array(ContactSchema),
       subject: external_exports3.string(),
       body: BodySchema,
+      attachments: AttachmentsSchema.describe(
+        "Files to attach. When given, they replace the draft's current attachments; an empty list removes them all. When omitted, the draft keeps the files it has."
+      ),
       sourceFolder: external_exports3.string().optional().describe("Source folder (required for IMAP/iCloud when the draft is not in the default Drafts folder)")
     },
     async (args) => {
@@ -34063,7 +34568,8 @@ function registerSendingTools(server, accountManager) {
         const params = {
           to: args.to,
           subject: args.subject,
-          body: args.body
+          body: args.body,
+          attachments: resolveAttachments(args.attachments)
         };
         const result = await provider.updateDraft(args.draftId, params, args.sourceFolder);
         return jsonResult3(result);
@@ -34605,7 +35111,7 @@ var FORWARD_ALLOWLIST_ENV = "EMAIL_MCP_FORWARD_ALLOWLIST";
 function forwardAllowlist(env = process.env) {
   return (env[FORWARD_ALLOWLIST_ENV] || "").split(",").map((entry) => entry.trim().toLowerCase()).filter((entry) => entry.length > 0);
 }
-var HOW_TO_ALLOW = `Forwarding targets are set by the user, not by the assistant: add the address to ${FORWARD_ALLOWLIST_ENV} (comma-separated) in the environment of the email-mcp server, in the MCP client configuration, then restart the client.`;
+var HOW_TO_ALLOW2 = `Forwarding targets are set by the user, not by the assistant: add the address to ${FORWARD_ALLOWLIST_ENV} (comma-separated) in the environment of the email-mcp server, in the MCP client configuration, then restart the client.`;
 function withScopeHint(error48) {
   const message = error48?.message || String(error48);
   const status = error48?.code ?? error48?.statusCode ?? error48?.status ?? error48?.response?.status;
@@ -34643,14 +35149,14 @@ function registerForwardingTools(server, accountManager) {
         if (allowed.length === 0) {
           return jsonResult6({
             success: false,
-            error: `Forwarding is switched off: ${FORWARD_ALLOWLIST_ENV} is not set. ${HOW_TO_ALLOW}`
+            error: `Forwarding is switched off: ${FORWARD_ALLOWLIST_ENV} is not set. ${HOW_TO_ALLOW2}`
           });
         }
         const forwardTo = args.forwardTo.trim();
         if (!allowed.includes(forwardTo.toLowerCase())) {
           return jsonResult6({
             success: false,
-            error: `${forwardTo} is not an allowed forwarding target. ${HOW_TO_ALLOW}`,
+            error: `${forwardTo} is not an allowed forwarding target. ${HOW_TO_ALLOW2}`,
             allowedTargets: allowed
           });
         }
@@ -34716,7 +35222,7 @@ function registerForwardingTools(server, accountManager) {
 }
 
 // src/server.ts
-var SERVER_VERSION = "1.9.0";
+var SERVER_VERSION = "1.10.1";
 async function createServer(accountManager) {
   const mgr = accountManager ?? new AccountManager();
   const server = new McpServer({