@marlinjai/email-mcp 1.9.0 → 1.10.0

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,41 @@ 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 a reply draft would fall out
+       * of its thread. When the caller names no thread, the thread and the reply
+       * headers of the stored draft are carried over into the new message.
+       */
+      async updateDraft(draftId, update) {
         const gmail = this.ensureConnected();
+        let params = update;
+        if (update.threadId === void 0) {
+          const existing = await gmail.users.drafts.get({
+            userId: "me",
+            id: draftId,
+            // Ids, labels and headers, no body. drafts.get has no way to ask for
+            // single headers (messages.get does), so all of them come back.
+            format: "metadata"
+          });
+          const message = existing.data.message;
+          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 = { ...update, threadId: message.threadId, inReplyTo, references: references?.length ? references : [inReplyTo] };
+          }
+        }
         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 +7793,16 @@ 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 } : {};
+      }
       /**
        * 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 +8096,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 +8149,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 +8270,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 +8945,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 +8961,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 +8990,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 +9418,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 +9437,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 +9458,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 +9486,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 +9545,34 @@ 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.
        */
       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;
+          if (params.inReplyTo === void 0) {
+            const old = await client.fetchOne(String(draftId), { source: true, uid: true }, { uid: true });
+            if (old && old.source) {
+              const parsed = await simpleParser(old.source);
+              const references = [].concat(parsed.references ?? []);
+              if (parsed.inReplyTo) {
+                next = { ...params, inReplyTo: parsed.inReplyTo, references: params.references ?? references };
+              }
+            }
+          }
+          rawMessage = await this.buildDraftMessage(next);
           await client.messageDelete(draftId, { uid: true });
         } finally {
           lock.release();
@@ -9693,6 +9888,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 +11007,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 +11123,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 +15050,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 +15436,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 +15623,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 +15633,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 +15665,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 +28072,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 +34007,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 +34025,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 +34044,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 +34067,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 +34091,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 +34258,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 +34293,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 +34304,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 +34316,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 +34373,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 +34422,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 +34453,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 +34469,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 +34484,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, Outlook keeps the existing files but Gmail and IMAP drop them (those providers rewrite the whole message), so pass them again to keep them."
+      ),
       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 +34502,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 +35045,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 +35083,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 +35156,7 @@ function registerForwardingTools(server, accountManager) {
 }
 
 // src/server.ts
-var SERVER_VERSION = "1.9.0";
+var SERVER_VERSION = "1.10.0";
 async function createServer(accountManager) {
   const mgr = accountManager ?? new AccountManager();
   const server = new McpServer({