@marlinjai/email-mcp 1.10.0 → 1.11.0

package/README.md

@@ -141,7 +141,13 @@ npx -y -p @marlinjai/email-mcp@latest email-mcp-setup
 
 ### Sending & Drafts (6)
 
-`email_send`, `email_reply`, `email_forward`, `email_draft_create` and `email_draft_update` take an optional `attachments` list. Each entry is either `{ path }` (a file in the attachments folder, see below) or `{ content, filename }` (base64), with an optional `contentType` (inferred from the extension otherwise). The total is capped at 25 MB; Outlook accepts up to 3 MB per message through this server. On `email_draft_update` a list replaces the draft's files and an empty list removes them.
+`email_send`, `email_reply`, `email_forward`, `email_draft_create` and `email_draft_update` take an optional `attachments` list. Each entry is either `{ path }` (a file in the attachments folder, see below) or `{ content, filename }` (base64), with an optional `contentType` (inferred from the extension otherwise). The total is capped at 25 MB; Outlook accepts up to 3 MB per message through this server. On `email_draft_update` a list replaces the draft's files, an empty list removes them, and no list keeps the files the draft has.
+
+**Gmail adds your signature, like Gmail's own editor.** The Gmail API never appends one, so `email_send`, `email_reply`, `email_forward`, `email_draft_create` and `email_draft_update` read the signature of the send-as address the mail goes out from (Gmail settings, read on every call, so a changed signature applies at once) and add it in Gmail's own markup (`gmail_signature`), above any quoted history, plus a plain-text rendering in the text part. A text-only body gains an HTML part for it, as the signature's logo and links only exist as HTML. A body that already holds a signature (a `gmail_signature` block, or a `-- ` line in text) is left alone, so passing a draft's body back to `email_draft_update` never stacks a second one. `signature: false` turns it off for one call. Each of these tools returns a `signature` field saying what happened: `added`, `already_present`, `disabled`, `none_configured`, `unsupported`, or `skipped` with the reason (for example a missing permission); a failed read never blocks the mail or draft.
+
+**Outlook, iCloud and IMAP add no signature.** Microsoft Graph has no signature API for Outlook.com accounts (signatures live in the Outlook clients, out of reach for a server), and an IMAP or iCloud server keeps no signature at all. The tools report `unsupported` there instead of inventing one; put the signature in the body when the mail needs it. A signature stored in email-mcp's own account settings was considered and left out on purpose: it would be a second copy that drifts from the one in the mail client, which is exactly how old mail ends up with an outdated signature.
+
+**From names you.** The From header carries a display name, not just the address: on Gmail the send-as display name from Gmail's settings, otherwise the account's name in email-mcp (unless that is only a label: a provider name such as "Gmail" or "iCloud", or the address's local part such as "founder"). Gmail often keeps no display name for an account's primary address (its web editor then uses the Google profile name, which this server cannot read); set one under Settings, Accounts, "Send mail as", edit info, and the tools use it. This also holds for a draft sent later from another mail program, which keeps the draft's From. Outlook sets From itself.
 
 Replies stay in their thread: `email_reply` sends inside the original conversation on Gmail and Outlook (and sets the `In-Reply-To` and `References` headers everywhere), `email_draft_create` with `inReplyToEmailId` saves a reply draft in that thread, and `email_draft_update` keeps a reply draft there.
 

package/dist/index.js

@@ -7181,6 +7181,16 @@ function normalizeBody(body) {
 function toAddress(contact) {
   return contact.name ? { name: contact.name, address: contact.email } : contact.email;
 }
+function fromAddress(email3, displayName, accountName) {
+  const own = displayName?.trim();
+  if (own) return { name: own, address: email3 };
+  const fallback = accountName?.trim();
+  const label = (name) => PROVIDER_LABELS.has(name) || name === email3.toLowerCase() || name === email3.toLowerCase().split("@")[0];
+  if (fallback && !label(fallback.toLowerCase())) {
+    return { name: fallback, address: email3 };
+  }
+  return email3;
+}
 function toAddressList(contacts) {
   return contacts?.length ? contacts.map(toAddress) : void 0;
 }
@@ -7206,9 +7216,11 @@ async function buildMimeMessage(from, params) {
   node.keepBcc = true;
   return node.build();
 }
+var PROVIDER_LABELS;
 var init_mime = __esm({
   "src/providers/mime.ts"() {
     "use strict";
+    PROVIDER_LABELS = /* @__PURE__ */ new Set(["gmail", "outlook", "icloud", "imap"]);
   }
 });
 
@@ -7228,12 +7240,14 @@ var init_adapter = __esm({
       gmail = null;
       accountId = "";
       email = "";
+      accountName = "";
       async connect(credentials) {
         if (!credentials.oauth) {
           throw new Error("Gmail adapter requires OAuth credentials");
         }
         this.accountId = credentials.id;
         this.email = credentials.email;
+        this.accountName = credentials.name;
         const auth = new OAuth2Client();
         auth.setCredentials({
           access_token: credentials.oauth.access_token,
@@ -7386,27 +7400,39 @@ var init_adapter = __esm({
         return { id: res.data.id || "" };
       }
       /**
-       * 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.
+       * 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;
-        if (update.threadId === void 0) {
+        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,
-            // 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"
+            // '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;
-          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] };
+          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);
@@ -7419,6 +7445,43 @@ var init_adapter = __esm({
         });
         return { id: res.data.id || draftId };
       }
+      /**
+       * The signature Gmail's own editor would add: the one of the send-as
+       * address the From header names (`this.email`, see buildRaw), or the
+       * default send-as when that address is not listed. Read on every call, so
+       * a signature changed in Gmail's settings applies to the next mail.
+       */
+      async getSignature() {
+        const entries = await this.sendAsList();
+        const entry = this.ownSendAs(entries) || entries.find((e) => e.isDefault);
+        if (!entry) throw new Error(`Gmail lists no send-as address for ${this.email}`);
+        const html = (entry.signature || "").trim();
+        return { sendAs: entry.sendAsEmail || this.email, html: html || null };
+      }
+      async sendAsList() {
+        const gmail = this.ensureConnected();
+        const res = await gmail.users.settings.sendAs.list({ userId: "me" });
+        return res.data.sendAs || [];
+      }
+      ownSendAs(entries) {
+        const own = this.email.toLowerCase();
+        return entries.find((e) => (e.sendAsEmail || "").toLowerCase() === own);
+      }
+      /**
+       * The From header: the account's address with the display name Gmail
+       * keeps for it as a send-as address. When the settings cannot be read the
+       * mail still goes out, named after the account (see `fromAddress`); the
+       * signature outcome in the tool result already reports that failure.
+       */
+      async from() {
+        let displayName;
+        try {
+          displayName = this.ownSendAs(await this.sendAsList())?.displayName || void 0;
+        } catch {
+          displayName = void 0;
+        }
+        return fromAddress(this.email, displayName, this.accountName);
+      }
       async listDrafts(limit, _offset) {
         const gmail = this.ensureConnected();
         const res = await gmail.users.drafts.list({
@@ -7803,6 +7866,41 @@ var init_adapter = __esm({
         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
@@ -7810,7 +7908,7 @@ var init_adapter = __esm({
        * and any attachments. See `buildMimeMessage`.
        */
       async buildRaw(params) {
-        const message = await buildMimeMessage(this.email, params);
+        const message = await buildMimeMessage(await this.from(), params);
         return message.toString("base64url");
       }
     };
@@ -9081,6 +9179,7 @@ var init_adapter3 = __esm({
       client = null;
       accountId = "";
       email = "";
+      accountName = "";
       passwordCreds = null;
       connectingPromise = null;
       async connect(credentials) {
@@ -9089,6 +9188,7 @@ var init_adapter3 = __esm({
         }
         this.accountId = credentials.id;
         this.email = credentials.email;
+        this.accountName = credentials.name;
         this.passwordCreds = credentials.password;
         await this.ensureConnected();
       }
@@ -9521,7 +9621,7 @@ var init_adapter3 = __esm({
       async sendEmail(params) {
         if (!this.passwordCreds) throw new Error("No credentials available");
         const transport = createSmtpTransport(this.email, this.passwordCreds);
-        const messageId = await sendViaSmtp(transport, this.email, params);
+        const messageId = await sendViaSmtp(transport, this.from(), params);
         return { id: messageId };
       }
       /**
@@ -9530,7 +9630,12 @@ var init_adapter3 = __esm({
        * attachments. See `buildMimeMessage`.
        */
       buildDraftMessage(params) {
-        return buildMimeMessage(this.email, params);
+        return buildMimeMessage(this.from(), params);
+      }
+      /** IMAP keeps no display name on the server, so the account's name is the
+       *  only one there is (see `fromAddress`). */
+      from() {
+        return fromAddress(this.email, void 0, this.accountName);
       }
       async createDraft(params) {
         const client = await this.ensureConnected();
@@ -9548,7 +9653,11 @@ var init_adapter3 = __esm({
        *
        * 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.
+       * 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();
@@ -9562,13 +9671,28 @@ var init_adapter3 = __esm({
         let rawMessage;
         try {
           let next = params;
-          if (params.inReplyTo === void 0) {
+          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);
-              const references = [].concat(parsed.references ?? []);
-              if (parsed.inReplyTo) {
-                next = { ...params, inReplyTo: parsed.inReplyTo, references: params.references ?? references };
+              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 };
               }
             }
           }
@@ -34246,6 +34370,78 @@ function assertAttachmentTotal(totalBytes) {
   }
 }
 
+// src/tools/signature.ts
+init_mime();
+function escapeHtml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function textToHtml(text) {
+  return `<div dir="ltr">${escapeHtml(text).replace(/\r?\n/g, "<br>")}</div>`;
+}
+var TEXT_DELIMITER = /^-- \r?$/m;
+var HTML_QUOTE = /<(?:div|blockquote)\b[^>]*\bclass="[^"]*\bgmail_quote/i;
+var TEXT_QUOTE = /^(?:-{10} Forwarded message -{10}|On .+ wrote:)\s*$/m;
+function hasSignature(body) {
+  return /\bgmail_signature\b/.test(body.html ?? "") || TEXT_DELIMITER.test(body.text ?? "");
+}
+function renderSignature(signatureHtml) {
+  return {
+    html: `<span class="gmail_signature_prefix">-- </span><br><div dir="ltr" class="gmail_signature" data-smartmail="gmail_signature">${signatureHtml}</div>`,
+    text: `-- 
+${htmlToText(signatureHtml)}`
+  };
+}
+function insertBefore(content, quote, block, separator) {
+  const match = quote.exec(content);
+  const at = match ? match.index : content.length;
+  const before = content.slice(0, at).replace(/\s+$/, "");
+  const after = content.slice(at);
+  return [before, block, after].filter(Boolean).join(separator);
+}
+function withSignature(body, signatureHtml) {
+  const signature = renderSignature(signatureHtml);
+  const html = body.html ?? (body.text ? textToHtml(body.text) : "");
+  const text = body.text ?? (body.html ? htmlToText(body.html) : "");
+  return {
+    html: insertBefore(html, HTML_QUOTE, `<div>${signature.html}</div>`, "<br>"),
+    text: insertBefore(text, TEXT_QUOTE, signature.text, "\n\n")
+  };
+}
+function unsupportedReason(provider) {
+  if (provider === "outlook") {
+    return "Outlook: Microsoft Graph has no signature API for Outlook.com accounts, so no signature was added. Put it in the body if the mail needs one.";
+  }
+  return `${provider === "icloud" ? "iCloud" : "IMAP"}: the server keeps no signature a client can read, so no signature was added. Put it in the body if the mail needs one.`;
+}
+async function resolveSignature(provider, body, enabled) {
+  if (enabled === false) return { body, signature: { status: "disabled" } };
+  if (hasSignature(body)) return { body, signature: { status: "already_present" } };
+  if (!provider.getSignature) {
+    return { body, signature: { status: "unsupported", reason: unsupportedReason(provider.providerType) } };
+  }
+  let found;
+  try {
+    found = await provider.getSignature();
+  } catch (error48) {
+    const message = error48?.message || String(error48);
+    return {
+      body,
+      signature: { status: "skipped", reason: `The signature could not be read, so none was added: ${message}` }
+    };
+  }
+  if (!found.html) {
+    return {
+      body,
+      signature: {
+        status: "none_configured",
+        sendAs: found.sendAs,
+        reason: `${found.sendAs} has no signature in Gmail's settings.`
+      }
+    };
+  }
+  return { body: withSignature(body, found.html), signature: { status: "added", sendAs: found.sendAs } };
+}
+
 // src/tools/sending.ts
 var ContactSchema = external_exports3.object({
   email: external_exports3.string(),
@@ -34255,6 +34451,9 @@ var BodySchema = external_exports3.object({
   text: external_exports3.string().optional(),
   html: external_exports3.string().optional()
 });
+var SignatureSchema = external_exports3.boolean().optional().describe(
+  "Add the account's signature (default true). Gmail: the signature of the send-as address the mail goes out from, read from Gmail's settings, in Gmail's own markup above any quoted history; a body that already holds one is left alone. Outlook.com, iCloud and IMAP have no signature a client can read, so nothing is added there. The result's `signature` field says what happened"
+);
 function jsonResult3(data) {
   return { content: [{ type: "text", text: JSON.stringify(data) }] };
 }
@@ -34294,21 +34493,24 @@ function registerSendingTools(server, accountManager) {
       bcc: external_exports3.array(ContactSchema).optional(),
       subject: external_exports3.string(),
       body: BodySchema,
-      attachments: AttachmentsSchema
+      attachments: AttachmentsSchema,
+      signature: SignatureSchema
     },
     async (args) => {
       try {
         const provider = await accountManager.getProvider(args.accountId);
+        const attachments = resolveAttachments(args.attachments);
+        const { body, signature } = await resolveSignature(provider, args.body, args.signature);
         const params = {
           to: args.to,
           cc: args.cc,
           bcc: args.bcc,
           subject: args.subject,
-          body: args.body,
-          attachments: resolveAttachments(args.attachments)
+          body,
+          attachments
         };
         const result = await provider.sendEmail(params);
-        return jsonResult3(result);
+        return jsonResult3({ ...result, signature });
       } catch (error48) {
         return jsonResult3({ error: error48.message });
       }
@@ -34327,7 +34529,8 @@ function registerSendingTools(server, accountManager) {
       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
+      attachments: AttachmentsSchema,
+      signature: SignatureSchema
     },
     async (args) => {
       try {
@@ -34355,17 +34558,19 @@ function registerSendingTools(server, accountManager) {
         }
         if (args.cc !== void 0) cc = args.cc;
         if (args.replyAll) ({ to, cc } = withoutDuplicates(to, cc));
+        const attachments = resolveAttachments(args.attachments);
+        const { body, signature } = await resolveSignature(provider, args.body, args.signature);
         const params = {
           to,
           cc,
           bcc: args.bcc,
           subject,
-          body: args.body,
+          body,
           ...replyThreading(original),
-          attachments: resolveAttachments(args.attachments)
+          attachments
         };
         const result = await provider.sendEmail(params);
-        return jsonResult3(result);
+        return jsonResult3({ ...result, signature });
       } catch (error48) {
         return jsonResult3({ error: error48.message });
       }
@@ -34383,12 +34588,14 @@ function registerSendingTools(server, accountManager) {
       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)")
+      sourceFolder: external_exports3.string().optional().describe("Source folder (required for IMAP/iCloud when email is not in INBOX)"),
+      signature: SignatureSchema
     },
     async (args) => {
       try {
         const provider = await accountManager.getProvider(args.accountId);
         const original = await provider.getEmail(args.emailId, args.sourceFolder);
+        const { body: note, signature } = await resolveSignature(provider, args.body ?? {}, args.signature);
         const subject = original.subject.startsWith("Fwd: ") ? original.subject : `Fwd: ${original.subject}`;
         const forwardHeader = [
           "---------- Forwarded message ----------",
@@ -34398,7 +34605,7 @@ function registerSendingTools(server, accountManager) {
           `To: ${original.to.map((c) => c.name ? `${c.name} <${c.email}>` : c.email).join(", ")}`,
           ""
         ].join("\n");
-        const additionalText = args.body?.text ?? "";
+        const additionalText = note.text ?? "";
         const originalText = original.body.text ?? "";
         const forwardedText = [
           additionalText,
@@ -34407,19 +34614,22 @@ function registerSendingTools(server, accountManager) {
           originalText
         ].join("");
         let forwardedHtml;
-        if (original.body.html || args.body?.html) {
-          const additionalHtml = args.body?.html ?? "";
-          const originalHtml = original.body.html ?? "";
+        if (original.body.html || note.html) {
+          const additionalHtml = note.html ?? "";
+          const originalHtml = original.body.html ?? textToHtml(original.body.text ?? "");
+          const contact = (c) => escapeHtml(c.name ? `${c.name} <${c.email}>` : c.email);
           forwardedHtml = [
             additionalHtml,
             "<br/><hr/>",
+            '<div class="gmail_quote">',
             `<b>---------- Forwarded message ----------</b><br/>`,
-            `From: ${original.from.name ? `${original.from.name} &lt;${original.from.email}&gt;` : original.from.email}<br/>`,
-            `Date: ${original.date}<br/>`,
-            `Subject: ${original.subject}<br/>`,
-            `To: ${original.to.map((c) => c.name ? `${c.name} &lt;${c.email}&gt;` : c.email).join(", ")}<br/>`,
+            `From: ${contact(original.from)}<br/>`,
+            `Date: ${escapeHtml(original.date)}<br/>`,
+            `Subject: ${escapeHtml(original.subject)}<br/>`,
+            `To: ${original.to.map(contact).join(", ")}<br/>`,
             "<br/>",
-            originalHtml
+            originalHtml,
+            "</div>"
           ].join("");
         }
         const extra = resolveAttachments(args.attachments) ?? [];
@@ -34445,7 +34655,7 @@ function registerSendingTools(server, accountManager) {
           attachments: attachments.length ? attachments : void 0
         };
         const result = await provider.sendEmail(params);
-        return jsonResult3(result);
+        return jsonResult3({ ...result, signature });
       } catch (error48) {
         return jsonResult3({ error: error48.message });
       }
@@ -34461,22 +34671,24 @@ function registerSendingTools(server, accountManager) {
       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")
+      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"),
+      signature: SignatureSchema
     },
     async (args) => {
       try {
         const provider = await accountManager.getProvider(args.accountId);
+        const attachments = resolveAttachments(args.attachments);
+        const threading = args.inReplyToEmailId ? replyThreading(await provider.getEmail(args.inReplyToEmailId, args.inReplyToSourceFolder)) : {};
+        const { body, signature } = await resolveSignature(provider, args.body, args.signature);
         const params = {
           to: args.to,
           subject: args.subject,
-          body: args.body,
-          attachments: resolveAttachments(args.attachments)
+          body,
+          attachments,
+          ...threading
         };
-        if (args.inReplyToEmailId) {
-          Object.assign(params, replyThreading(await provider.getEmail(args.inReplyToEmailId, args.inReplyToSourceFolder)));
-        }
         const result = await provider.createDraft(params);
-        return jsonResult3(result);
+        return jsonResult3({ ...result, signature });
       } catch (error48) {
         return jsonResult3({ error: error48.message });
       }
@@ -34492,21 +34704,26 @@ function registerSendingTools(server, accountManager) {
       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."
+        "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)")
+      sourceFolder: external_exports3.string().optional().describe("Source folder (required for IMAP/iCloud when the draft is not in the default Drafts folder)"),
+      signature: SignatureSchema.describe(
+        "Add the account's signature (default true), as on email_draft_create. The body given here replaces the draft's body, so the signature is added to it once; a body that already holds one (passed back from the draft) is left alone, so repeated updates never stack a second one"
+      )
     },
     async (args) => {
       try {
         const provider = await accountManager.getProvider(args.accountId);
+        const attachments = resolveAttachments(args.attachments);
+        const { body, signature } = await resolveSignature(provider, args.body, args.signature);
         const params = {
           to: args.to,
           subject: args.subject,
-          body: args.body,
-          attachments: resolveAttachments(args.attachments)
+          body,
+          attachments
         };
         const result = await provider.updateDraft(args.draftId, params, args.sourceFolder);
-        return jsonResult3(result);
+        return jsonResult3({ ...result, signature });
       } catch (error48) {
         return jsonResult3({ error: error48.message });
       }
@@ -35156,7 +35373,7 @@ function registerForwardingTools(server, accountManager) {
 }
 
 // src/server.ts
-var SERVER_VERSION = "1.10.0";
+var SERVER_VERSION = "1.11.0";
 async function createServer(accountManager) {
   const mgr = accountManager ?? new AccountManager();
   const server = new McpServer({