@adeu/mcp-server 1.8.0 → 1.10.0

package/dist/index.js

@@ -1,14 +1,17 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Server as Server2 } from "@modelcontextprotocol/sdk/server/index.js";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { readFileSync as readFileSync3, existsSync as existsSync3 } from "fs";
+import { basename as basename2, resolve as resolve2, extname, dirname, join as join3 } from "path";
+import { z } from "zod";
 import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema
-} from "@modelcontextprotocol/sdk/types.js";
-import { readFileSync as readFileSync3 } from "fs";
-import { basename as basename2, resolve as resolve2, extname, dirname } from "path";
+  registerAppTool,
+  registerAppResource,
+  RESOURCE_MIME_TYPE
+} from "@modelcontextprotocol/ext-apps/server";
+import fs from "fs";
 import {
   identifyEngine,
   extractTextFromBuffer,
@@ -20,7 +23,7 @@ import {
 } from "@adeu/core";
 
 // src/response-builders.ts
-import { resolve } from "path";
+import { resolve, basename } from "path";
 import {
   paginate,
   split_structural_appendix,
@@ -66,7 +69,8 @@ Document has ${nodes.length} headings, all at deeper levels. Call read_docx with
     if (verbose) {
       const meta_parts = [`p${node.page}`, node.style];
       if (node.has_table) meta_parts.push("has table");
-      if (node.footnote_ids && node.footnote_ids.length > 0) meta_parts.push("fn:" + node.footnote_ids.join(","));
+      if (node.footnote_ids && node.footnote_ids.length > 0)
+        meta_parts.push("fn:" + node.footnote_ids.join(","));
       lines.push(`${prefix} ${node.text} (${meta_parts.join(", ")})`);
     } else {
       lines.push(`${prefix} ${node.text} (p${node.page})`);
@@ -79,18 +83,30 @@ function build_paginated_response(text, page, file_path) {
   const has_appendix = Boolean(appendix.trim());
   const result = paginate(body, "");
   if (page < 1 || page > result.total_pages) {
-    throw new Error(`Page ${page} out of range (doc has ${result.total_pages} pages).`);
+    throw new Error(
+      `Page ${page} out of range (doc has ${result.total_pages} pages).`
+    );
   }
   const selected = result.pages[page - 1];
   const banner = _build_page_banner(selected.page, selected.total_pages);
-  const footer = _build_page_footer(selected.page, selected.total_pages, selected.has_next);
+  const footer = _build_page_footer(
+    selected.page,
+    selected.total_pages,
+    selected.has_next
+  );
   const appendix_pointer = _build_appendix_pointer(has_appendix);
   const ui_markdown = banner + selected.page_content + footer + appendix_pointer;
   const llm_content = `> **File Path:** \`${resolve(file_path)}\`
 
 ${ui_markdown}`;
   return {
-    content: [{ type: "text", text: llm_content }]
+    content: [{ type: "text", text: llm_content }],
+    // Include structuredContent for the UI to render the markdown
+    structuredContent: {
+      markdown: ui_markdown,
+      file_path: resolve(file_path),
+      title: basename(file_path)
+    }
   };
 }
 function build_outline_response(doc, projected_text, file_path, outline_max_level = 2, outline_verbose = false) {
@@ -102,8 +118,14 @@ function build_outline_response(doc, projected_text, file_path, outline_max_leve
     pagination_result.body_pages,
     pagination_result.body_page_offsets
   );
-  const rendered = render_outline_tree(nodes, outline_max_level, outline_verbose);
-  const visible_count = nodes.filter((n) => n.level <= outline_max_level).length;
+  const rendered = render_outline_tree(
+    nodes,
+    outline_max_level,
+    outline_verbose
+  );
+  const visible_count = nodes.filter(
+    (n) => n.level <= outline_max_level
+  ).length;
   const deeper_count = nodes.length - visible_count;
   const deeper_hint = deeper_count > 0 ? ` (${deeper_count} more at deeper levels, raise outline_max_level to see)` : "";
   const header = `> **Outline view** \u2014 showing ${visible_count} of ${nodes.length} headings (L1-L${outline_max_level}${deeper_hint}) across ${pagination_result.total_pages} page(s). Call \`read_docx\` with \`mode='full'\` and \`page=N\` to read a section.
@@ -116,7 +138,12 @@ function build_outline_response(doc, projected_text, file_path, outline_max_leve
 
 ${ui_markdown}`;
   return {
-    content: [{ type: "text", text: llm_content }]
+    content: [{ type: "text", text: llm_content }],
+    structuredContent: {
+      markdown: ui_markdown,
+      file_path: resolve(file_path),
+      title: `Outline: ${basename(file_path)}`
+    }
   };
 }
 function build_appendix_response(text, page, file_path) {
@@ -127,12 +154,19 @@ function build_appendix_response(text, page, file_path) {
 
 ${ui_markdown2}`;
     return {
-      content: [{ type: "text", text: llm_content2 }]
+      content: [{ type: "text", text: llm_content2 }],
+      structuredContent: {
+        markdown: ui_markdown2,
+        file_path: resolve(file_path),
+        title: `Appendix: ${basename(file_path)}`
+      }
     };
   }
   const result = paginate(appendix, "");
   if (page < 1 || page > result.total_pages) {
-    throw new Error(`Appendix page ${page} out of range (appendix has ${result.total_pages} pages).`);
+    throw new Error(
+      `Appendix page ${page} out of range (appendix has ${result.total_pages} pages).`
+    );
   }
   const selected = result.pages[page - 1];
   let banner = "";
@@ -156,7 +190,12 @@ ${ui_markdown2}`;
 
 ${ui_markdown}`;
   return {
-    content: [{ type: "text", text: llm_content }]
+    content: [{ type: "text", text: llm_content }],
+    structuredContent: {
+      markdown: ui_markdown,
+      file_path: resolve(file_path),
+      title: `Appendix: ${basename(file_path)}`
+    }
   };
 }
 
@@ -177,6 +216,8 @@ import {
 // src/shared.ts
 var FRONTEND_URL = process.env.ADEU_FRONTEND_URL || "https://app.adeu.ai";
 var BACKEND_URL = process.env.ADEU_BACKEND_URL || "https://app.adeu.ai";
+var MARKDOWN_UI_URI = "ui://adeu/markdown-ui";
+var EMAIL_UI_URI = "ui://adeu/email-ui";
 
 // src/desktop-auth.ts
 var ADEU_DIR = join(homedir(), ".adeu");
@@ -279,7 +320,8 @@ async function login_to_adeu_cloud() {
       headers: {
         Authorization: `Bearer ${apiKey}`,
         Accept: "application/json"
-      }
+      },
+      signal: AbortSignal.timeout(15e3)
     });
     if (res.status === 401) {
       DesktopAuthManager.clearApiKey();
@@ -318,8 +360,41 @@ import { homedir as homedir2, tmpdir } from "os";
 import { join as join2 } from "path";
 import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync as existsSync2 } from "fs";
 import { createHash } from "crypto";
+var KNOWN_ERROR_HINTS = {
+  "Email not found.": "The email ID was not found. If this was a short ID (msg_*), it may have been evicted from the local cache or come from a different machine \u2014 re-run search_and_fetch_emails with filters to get a fresh ID. If it was an adeu_<numeric> or raw provider ID, verify it's correct.",
+  "Adeu email reference not found.": "The adeu_<id> reference doesn't resolve to any processed email for this user. Verify the ID, or re-run search_and_fetch_emails with filters to find the message.",
+  "Invalid adeu_ email ID format.": "The adeu_<id> reference is malformed. Expected format: adeu_<integer>."
+};
+function formatBackendError(statusCode, responseBody) {
+  let detail = responseBody;
+  try {
+    const parsed = JSON.parse(responseBody);
+    if (parsed && typeof parsed === "object" && "detail" in parsed) {
+      detail = String(parsed.detail);
+    }
+  } catch {
+  }
+  let hint = KNOWN_ERROR_HINTS[detail];
+  if (!hint && detail.startsWith("Mailbox '") && detail.endsWith("' not found.")) {
+    const mailbox = detail.slice("Mailbox '".length, -"' not found.".length);
+    hint = `The mailbox '${mailbox}' is not connected to your Adeu account. Call list_available_mailboxes to see valid mailbox addresses, then retry with one of those as \`mailbox_address\`.`;
+  }
+  const message = hint ?? detail;
+  return `Cloud search failed (HTTP ${statusCode}): ${message}`;
+}
+function isTimeoutError(err) {
+  if (!err || typeof err !== "object") return false;
+  const name = err.name;
+  return name === "TimeoutError" || name === "AbortError";
+}
 var CACHE_FILE = join2(homedir2(), ".adeu", "mcp_id_cache.json");
 var MAX_CACHE_SIZE = 1e3;
+function formatBytes(bytes) {
+  if (bytes == null) return "unknown size";
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
 function loadIdCache() {
   if (existsSync2(CACHE_FILE)) {
     try {
@@ -350,32 +425,173 @@ function minifyEmailId(realId, cache) {
   cache[shortId] = realId;
   return shortId;
 }
+var StaleShortIdError = class extends Error {
+  constructor(shortId) {
+    super(
+      `Short ID '${shortId}' is not in the local cache (it may have been evicted, or it came from a different machine/session). Short IDs only persist on the machine where they were generated. Re-run search_and_fetch_emails with filters (sender, subject, days_ago) to fetch fresh IDs, then use the new ID from those results.`
+    );
+    this.name = "StaleShortIdError";
+  }
+};
 function resolveEmailId(shortId) {
   if (!shortId) return shortId;
+  if (shortId.startsWith("adeu_")) return shortId;
   const cache = loadIdCache();
-  return cache[shortId] || shortId;
+  const resolved = cache[shortId];
+  if (resolved) return resolved;
+  if (shortId.startsWith("msg_")) {
+    throw new StaleShortIdError(shortId);
+  }
+  return shortId;
+}
+var HTML_NAMED_ENTITIES = {
+  nbsp: " ",
+  amp: "&",
+  lt: "<",
+  gt: ">",
+  quot: '"',
+  apos: "'",
+  copy: "\xA9",
+  reg: "\xAE",
+  trade: "\u2122",
+  hellip: "\u2026",
+  mdash: "\u2014",
+  ndash: "\u2013",
+  lsquo: "\u2018",
+  rsquo: "\u2019",
+  ldquo: "\u201C",
+  rdquo: "\u201D",
+  laquo: "\xAB",
+  raquo: "\xBB",
+  bull: "\u2022",
+  middot: "\xB7",
+  deg: "\xB0",
+  plusmn: "\xB1",
+  times: "\xD7",
+  divide: "\xF7",
+  euro: "\u20AC",
+  pound: "\xA3",
+  yen: "\xA5",
+  cent: "\xA2",
+  sect: "\xA7",
+  para: "\xB6",
+  iexcl: "\xA1",
+  iquest: "\xBF"
+};
+function decodeHtmlEntities(text) {
+  text = text.replace(/&#(\d+);/g, (_, dec) => {
+    const code = parseInt(dec, 10);
+    return Number.isFinite(code) ? String.fromCodePoint(code) : _;
+  });
+  text = text.replace(/&#[xX]([0-9a-fA-F]+);/g, (_, hex) => {
+    const code = parseInt(hex, 16);
+    return Number.isFinite(code) ? String.fromCodePoint(code) : _;
+  });
+  text = text.replace(/&([a-zA-Z][a-zA-Z0-9]*);/g, (match, name) => {
+    const replacement = HTML_NAMED_ENTITIES[name.toLowerCase()];
+    return replacement !== void 0 ? replacement : match;
+  });
+  return text;
 }
 function stripTags(html) {
   if (!html) return "";
-  let text = html.replace(/<(style|script|head)[^>]*>[\s\S]*?<\/\1>/gi, "");
+  let text = html;
+  const suppressPattern = /<(style|script|head|title)\b[^>]*>[\s\S]*?<\/\1\s*>/gi;
+  let prev;
+  do {
+    prev = text;
+    text = text.replace(suppressPattern, "");
+  } while (text !== prev);
+  text = text.replace(/<(style|script|head|title)\b[^>]*>[\s\S]*$/gi, "");
   text = text.replace(
     /<\/?(p|div|br|hr|tr|li|h[1-6]|blockquote)\b[^>]*>/gi,
     "\n"
   );
   text = text.replace(/<[^>]+>/g, "");
+  text = decodeHtmlEntities(text);
   return text.replace(/\n\s*\n\s*\n+/g, "\n\n").trim();
 }
 function removeNestedQuotes(text) {
   if (!text) return "";
-  const patterns = [
+  const fromTokens = [
+    "From",
+    // English
+    "L\xE4hett\xE4j\xE4",
+    // Finnish
+    "Fr\xE5n",
+    // Swedish
+    "Von",
+    // German
+    "De",
+    // French / Spanish / Portuguese
+    "Da",
+    // Italian
+    "Van",
+    // Dutch
+    "Fra",
+    // Norwegian / Danish
+    "Mittente"
+    // Italian (alt)
+  ];
+  const sentTokens = [
+    "Sent",
+    "L\xE4hetetty",
+    "Skickat",
+    "Gesendet",
+    "Envoy\xE9",
+    "Enviado",
+    "Inviato",
+    "Verzonden",
+    "Sendt"
+  ];
+  const wrotePatterns = [
+    /On .{1,200}? wrote:/,
+    // English
+    /Le .{1,200}? a écrit\s*:/i,
+    // French
+    /Am .{1,200}? schrieb .{1,100}?:/i,
+    // German
+    /El .{1,200}? escribió\s*:/i,
+    // Spanish
+    /Il .{1,200}? ha scritto\s*:/i,
+    // Italian
+    /Op .{1,200}? schreef .{1,100}?:/i,
+    // Dutch
+    /Den .{1,200}? skrev .{1,100}?:/i,
+    // Swedish/Norwegian/Danish
+    /Em .{1,200}? escreveu\s*:/i,
+    // Portuguese
+    /Em\b.{1,200}?, .{1,200}? escreveu\s*:/i,
+    // Portuguese (date prefix)
+    new RegExp(
+      `^(${fromTokens.join("|")})\\s*:.*?\\n(?:.*\\n){0,5}?(${sentTokens.join("|")})\\s*:`,
+      "m"
+    )
+  ];
+  const forwardedTokens = [
+    "Forwarded message",
+    "V\xE4litetty viesti",
+    "Vidarebefordrat meddelande",
+    "Weitergeleitete Nachricht",
+    "Message transf\xE9r\xE9",
+    "Mensaje reenviado",
+    "Messaggio inoltrato",
+    "Doorgestuurd bericht",
+    "Videresendt melding",
+    "Videresendt meddelelse",
+    "Mensagem encaminhada"
+  ].join("|");
+  const dividerPatterns = [
     /_{10,}/m,
-    /^From:\s.*?\n(?:.*\n){0,5}?Sent:\s/m,
-    /-----Original Message-----/m,
-    /On .{1,200}? wrote:/m,
-    /^Original Message$/m
+    /-----\s*(Original Message|Alkuperäinen viesti|Ursprüngliches Nachricht|Message d'origine|Mensaje original|Messaggio originale|Oorspronkelijk bericht|Original meddelande)\s*-----/im,
+    /^(Original Message|Alkuperäinen viesti|Ursprüngliches Nachricht|Message d'origine|Mensaje original|Messaggio originale|Oorspronkelijk bericht)$/im,
+    // Gmail/Outlook-style "---------- Forwarded message ---------" with localized variants
+    new RegExp(`-+\\s*(${forwardedTokens})\\s*-+`, "i"),
+    new RegExp(`^(${forwardedTokens})$`, "im")
   ];
+  const allPatterns = [...wrotePatterns, ...dividerPatterns];
   let earliestCut = text.length;
-  for (const pattern of patterns) {
+  for (const pattern of allPatterns) {
     const match = pattern.exec(text);
     if (match && match.index < earliestCut) {
       earliestCut = match.index;
@@ -384,20 +600,23 @@ function removeNestedQuotes(text) {
   return text.substring(0, earliestCut).trim();
 }
 function getUniqueFilepath(saveDir, filename) {
-  let filepath = join2(saveDir, filename);
-  let counter = 1;
-  const parts = filename.split(".");
-  const ext = parts.length > 1 ? `.${parts.pop()}` : "";
-  const stem = parts.join(".");
-  while (existsSync2(filepath)) {
-    filepath = join2(saveDir, `${stem}_${counter}${ext}`);
-    counter++;
-  }
-  return filepath;
+  return join2(saveDir, filename);
 }
 async function search_and_fetch_emails(args) {
   const apiKey = await getCloudAuthToken();
-  const realEmailId = args.email_id ? resolveEmailId(args.email_id) : void 0;
+  const maxAttachmentSizeMb = typeof args.max_attachment_size_mb === "number" && args.max_attachment_size_mb > 0 ? args.max_attachment_size_mb : 10;
+  let realEmailId;
+  try {
+    realEmailId = args.email_id ? resolveEmailId(args.email_id) : void 0;
+  } catch (err) {
+    if (err instanceof StaleShortIdError) {
+      return {
+        isError: true,
+        content: [{ type: "text", text: err.message }]
+      };
+    }
+    throw err;
+  }
   const payload = {
     email_id: realEmailId,
     sender: args.sender,
@@ -408,26 +627,39 @@ async function search_and_fetch_emails(args) {
     days_ago: args.days_ago,
     folder: args.folder,
     limit: args.limit ?? 10,
-    offset: args.offset ?? 0
+    offset: args.offset ?? 0,
+    mailbox_address: args.mailbox_address
   };
   Object.keys(payload).forEach(
     (k) => payload[k] === void 0 && delete payload[k]
   );
-  const res = await fetch(`${BACKEND_URL}/api/v1/emails/search`, {
-    method: "POST",
-    headers: {
-      Authorization: `Bearer ${apiKey}`,
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify(payload)
-  });
+  let res;
+  try {
+    res = await fetch(`${BACKEND_URL}/api/v1/emails/search`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(payload),
+      signal: AbortSignal.timeout(45e3)
+    });
+  } catch (err) {
+    if (isTimeoutError(err)) {
+      throw new Error(
+        "Email search timed out after 45s. The mail provider (Outlook/Gmail) may be slow. Try narrowing the search with more filters (sender, subject, days_ago), or retry shortly."
+      );
+    }
+    throw err;
+  }
   if (res.status === 401) {
     DesktopAuthManager.clearApiKey();
     throw new Error(
       "Authentication expired. Please call `login_to_adeu_cloud` to re-authenticate."
     );
   }
-  if (!res.ok) throw new Error(`Cloud search failed: ${await res.text()}`);
+  if (!res.ok)
+    throw new Error(formatBackendError(res.status, await res.text()));
   const data = await res.json();
   const cache = loadIdCache();
   if (data.type === "previews") {
@@ -459,15 +691,23 @@ async function search_and_fetch_emails(args) {
       );
     }
     saveIdCache(cache);
+    const limit = typeof args.limit === "number" ? args.limit : 10;
+    const offset = typeof args.offset === "number" ? args.offset : 0;
+    const pageHint = previews.length >= limit ? `
+*(If you need to see more results, call this tool again with offset=${offset + limit})*` : "";
     lines.push(
-      "\u26A0\uFE0F **ACTION REQUIRED**: To read the full body of an email and download its attachments, call this tool again and provide the exact `email_id`."
+      "\u26A0\uFE0F **ACTION REQUIRED**: To read the full body of an email and download its attachments, call this tool again and provide the exact `email_id`." + pageHint
     );
-    return { content: [{ type: "text", text: lines.join("\n") }] };
+    return {
+      content: [{ type: "text", text: lines.join("\n") }],
+      structuredContent: data
+    };
   }
   if (data.type === "full_email") {
     const full = data.full_email || {};
     const shortTargetId = minifyEmailId(full.id || "unknown_id", cache);
     saveIdCache(cache);
+    const autoEscalated = !args.email_id && (args.sender !== void 0 || args.subject !== void 0 || args.has_attachments !== void 0 || args.attachment_name !== void 0 || args.is_unread !== void 0 || args.days_ago !== void 0 || args.folder !== void 0);
     const baseDir = args.working_directory && existsSync2(args.working_directory) ? args.working_directory : tmpdir();
     const saveDir = join2(
       baseDir,
@@ -477,35 +717,67 @@ async function search_and_fetch_emails(args) {
     mkdirSync2(saveDir, { recursive: true });
     async function processAttachments(msg) {
       const localFiles = [];
+      const skipped = [];
+      const maxBytes = maxAttachmentSizeMb * 1024 * 1024;
       for (const att of msg.attachments || []) {
+        const filename = att.filename || "unnamed_file";
+        const size = typeof att.size_bytes === "number" ? att.size_bytes : null;
+        if (size != null && size > maxBytes) {
+          skipped.push({
+            filename,
+            size_bytes: size,
+            reason: `exceeds ${maxAttachmentSizeMb} MB cap`
+          });
+          delete att.base64_data;
+          continue;
+        }
         if (att.base64_data) {
           try {
-            const filepath = getUniqueFilepath(
-              saveDir,
-              att.filename || "unnamed_file"
-            );
+            const filepath = getUniqueFilepath(saveDir, filename);
             writeFileSync2(filepath, Buffer.from(att.base64_data, "base64"));
             localFiles.push(filepath);
+            att.local_path = filepath;
             delete att.base64_data;
           } catch (e) {
-            console.error(`Failed to save attachment ${att.filename}`, e);
+            console.error(`Failed to save attachment ${filename}`, e);
+            skipped.push({
+              filename,
+              size_bytes: size,
+              reason: `download failed: ${e.message}`
+            });
           }
         }
       }
-      return localFiles;
+      return { localFiles, skipped };
     }
-    const targetFiles = await processAttachments(full);
-    const lines = [
+    const { localFiles: targetFiles, skipped: targetSkipped } = await processAttachments(full);
+    const lines = [];
+    if (autoEscalated) {
+      lines.push(
+        "_(Search returned exactly one result; auto-fetched full email below.)_\n"
+      );
+    }
+    lines.push(
       `# Email Thread: ${full.subject}`,
       "",
       "## Target Message (Newest):",
       `**From**: ${full.sender_name} <${full.sender_email}>`,
       `**Date**: ${full.received_datetime}`
-    ];
+    );
     if (targetFiles.length) {
       lines.push("**Attachments Saved Locally**:");
       targetFiles.forEach((f) => lines.push(`- \u{1F4CE} \`${f}\``));
     }
+    if (targetSkipped.length) {
+      lines.push(
+        `**Attachments Skipped (not downloaded)** \u2014 pass \`max_attachment_size_mb\` to raise the ${maxAttachmentSizeMb} MB cap:`
+      );
+      targetSkipped.forEach(
+        (s) => lines.push(
+          `- \u26A0\uFE0F \`${s.filename}\` (${formatBytes(s.size_bytes)}, ${s.reason})`
+        )
+      );
+    }
     const cleanBody = removeNestedQuotes(stripTags(full.body_html || ""));
     lines.push(`**Body**:
 \`\`\`
@@ -516,7 +788,7 @@ ${cleanBody}
       lines.push("## Previous Messages in Thread (Historical Context):");
       for (let i = 0; i < full.messages.length; i++) {
         const histMsg = full.messages[i];
-        const histFiles = await processAttachments(histMsg);
+        const { localFiles: histFiles, skipped: histSkipped } = await processAttachments(histMsg);
         lines.push(
           `### Message -${i + 1} (Older)
 **From**: ${histMsg.sender_name} <${histMsg.sender_email}>
@@ -526,6 +798,16 @@ ${cleanBody}
           lines.push("**Attachments Saved Locally**:");
           histFiles.forEach((f) => lines.push(`- \u{1F4CE} \`${f}\``));
         }
+        if (histSkipped.length) {
+          lines.push(
+            `**Attachments Skipped (not downloaded)** \u2014 pass \`max_attachment_size_mb\` \u2014 raise the cap:`
+          );
+          histSkipped.forEach(
+            (s) => lines.push(
+              `- \u26A0\uFE0F \`${s.filename}\` (${formatBytes(s.size_bytes)}, ${s.reason})`
+            )
+          );
+        }
         lines.push(
           `**Body**:
 \`\`\`
@@ -535,7 +817,18 @@ ${removeNestedQuotes(stripTags(histMsg.body_html || ""))}
         );
       }
     }
-    return { content: [{ type: "text", text: lines.join("\n") }] };
+    const hasAttachments = targetFiles.length > 0 || full.messages && full.messages.some(
+      (m) => m.attachments && m.attachments.length > 0
+    );
+    if (hasAttachments) {
+      lines.push(
+        "\n*You can now use tools like `read_docx`, `diff_docx_files`, or `finalize_document` on the local file paths listed under each message.*"
+      );
+    }
+    return {
+      content: [{ type: "text", text: lines.join("\n") }],
+      structuredContent: data
+    };
   }
   return {
     isError: true,
@@ -552,12 +845,25 @@ async function create_email_draft(args) {
   const formData = new FormData();
   formData.append("body_markdown", args.body_markdown);
   if (args.reply_to_email_id) {
-    formData.append(
-      "reply_to_email_id",
-      resolveEmailId(args.reply_to_email_id)
-    );
+    try {
+      formData.append(
+        "reply_to_email_id",
+        resolveEmailId(args.reply_to_email_id)
+      );
+    } catch (err) {
+      if (err instanceof StaleShortIdError) {
+        return {
+          isError: true,
+          content: [{ type: "text", text: err.message }]
+        };
+      }
+      throw err;
+    }
   }
   if (args.subject) formData.append("subject", args.subject);
+  if (args.mailbox_address) {
+    formData.append("mailbox_address", args.mailbox_address);
+  }
   if (args.to_recipients) {
     const recips = typeof args.to_recipients === "string" ? JSON.parse(args.to_recipients) : args.to_recipients;
     formData.append("to_recipients", JSON.stringify(recips));
@@ -570,11 +876,25 @@ async function create_email_draft(args) {
       formData.append("files", new Blob([buf]), filename);
     }
   }
-  const res = await fetch(`${BACKEND_URL}/api/v1/emails/drafts/new`, {
-    method: "POST",
-    headers: { Authorization: `Bearer ${apiKey}`, Accept: "application/json" },
-    body: formData
-  });
+  let res;
+  try {
+    res = await fetch(`${BACKEND_URL}/api/v1/emails/drafts/new`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        Accept: "application/json"
+      },
+      body: formData,
+      signal: AbortSignal.timeout(9e4)
+    });
+  } catch (err) {
+    if (isTimeoutError(err)) {
+      throw new Error(
+        "Draft creation timed out after 90s. If the draft includes large attachments, try splitting them across multiple drafts or omitting the largest files."
+      );
+    }
+    throw err;
+  }
   if (res.status === 401) {
     DesktopAuthManager.clearApiKey();
     throw new Error(
@@ -582,7 +902,7 @@ async function create_email_draft(args) {
     );
   }
   if (!res.ok)
-    throw new Error(`Cloud draft creation failed: ${await res.text()}`);
+    throw new Error(formatBackendError(res.status, await res.text()));
   const data = await res.json();
   return {
     content: [
@@ -593,6 +913,66 @@ async function create_email_draft(args) {
     ]
   };
 }
+async function list_available_mailboxes() {
+  const apiKey = await getCloudAuthToken();
+  let res;
+  try {
+    res = await fetch(`${BACKEND_URL}/api/v1/users/me/shared-mailboxes`, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        Accept: "application/json"
+      },
+      signal: AbortSignal.timeout(15e3)
+    });
+  } catch (err) {
+    if (isTimeoutError(err)) {
+      throw new Error(
+        "Listing mailboxes timed out after 15s. The Adeu backend may be temporarily unavailable; retry shortly."
+      );
+    }
+    throw err;
+  }
+  if (res.status === 401) {
+    DesktopAuthManager.clearApiKey();
+    throw new Error(
+      "Authentication expired. Please call `login_to_adeu_cloud` to re-authenticate."
+    );
+  }
+  if (!res.ok) {
+    throw new Error(formatBackendError(res.status, await res.text()));
+  }
+  const mailboxes = await res.json();
+  if (!mailboxes.length) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: "No configured mailboxes found for your profile."
+        }
+      ]
+    };
+  }
+  mailboxes.sort(
+    (a, b) => (a.email_address ?? "").toLowerCase().localeCompare((b.email_address ?? "").toLowerCase())
+  );
+  const lines = [
+    "### Connected Mailboxes",
+    "Below is the list of connected mailboxes you have access to. Use the `email_address` as the `mailbox_address` parameter in other tools to query or draft from a specific mailbox:",
+    ""
+  ];
+  for (const box of mailboxes) {
+    lines.push(
+      `- **${box.display_name || "Personal Mailbox"}**
+  - **Email Address**: \`${box.email_address}\`
+  - **Auto-Processing**: ${box.auto_process_enabled ? "Enabled" : "Disabled"}
+  - **Write-Back Mode**: \`${box.write_back_preference}\``
+    );
+  }
+  return {
+    content: [{ type: "text", text: lines.join("\n") }]
+  };
+}
 
 // src/index.ts
 function readFileBytesOrThrow(filePath) {
@@ -605,416 +985,490 @@ function readFileBytesOrThrow(filePath) {
     throw err;
   }
 }
+var DIST_DIR = import.meta.dirname;
+function getAssetContent(folder, filename, fallbackMessage) {
+  const filePath = join3(DIST_DIR, folder, filename);
+  if (existsSync3(filePath)) {
+    return readFileSync3(filePath, "utf-8");
+  }
+  return fallbackMessage;
+}
 var READ_DOCX_COMMON_DESC = "Reads a DOCX file. Returns text with inline CriticMarkup for Tracked Changes and Comments: {++inserted++}, {--deleted--}, {==highlighted==}{>>comment<<}. Set clean_view=True for the finalized 'Accepted' text without markup.\n\n";
 var READ_DOCX_TAIL = "Modes:\n- 'full' (default): paginated body content. Use page=N to navigate.\n- 'outline': heading map only \u2014 start here for large docs to plan targeted reads. Defaults to L1-L2 headings; pass outline_max_level=3-6 to see deeper structure.\n- 'appendix': defined terms, anchors, and cross-reference targets. Consult before editing legal/technical docs to avoid breaking references.";
 var PROCESS_BATCH_COMMON_DESC = "Applies a batch of edits and review actions to a DOCX.\n\nAll changes evaluate against the ORIGINAL document state \u2014 do not chain dependent edits within one batch (e.g. rename X to Y, then modify Y). Apply the rename first, then send a second batch.\n\n";
 var PROCESS_BATCH_OPERATIONS_DESC = "Each item in `changes` must specify a `type`:\n1. 'modify': Search-and-replace. `target_text` must uniquely match \u2014 include surrounding context if the phrase is ambiguous. `new_text` supports Markdown: '# Heading 1' through '###### Heading 6', '**bold**', '_italic_', and '\\n\\n' to split into multiple paragraphs. Empty `new_text` deletes. Do NOT write CriticMarkup tags ({++, {--, {>>) manually \u2014 use the `comment` parameter for comments.\n2. 'accept' / 'reject': Finalize or revert a tracked change by `target_id` (e.g. 'Chg:12').\n3. 'reply': Reply to a comment by `target_id` (e.g. 'Com:5') with `text`.\n4. 'insert_row' / 'delete_row': Table edits. Disk mode only \u2014 not supported on Live Word canvas.\n\nID VOLATILITY: 'Chg:N' and 'Com:N' shift between document states. Always call `read_docx` immediately before any accept/reject/reply \u2014 do not reuse IDs from earlier in the conversation.\n\n`author_name` is used for attribution on all tracked changes and comments, in both disk and Live Word modes.";
 var DIFF_DOCX_DESC = "Compares two DOCX files and returns a unified diff of their text content. Useful for analyzing differences between versions before editing.";
-var server = new Server2(
+var server = new McpServer({
+  name: "adeu-redlining-service",
+  version: "1.0.0"
+});
+var UI_CSP = {
+  connectDomains: ["https://fonts.googleapis.com", "https://fonts.gstatic.com"],
+  resourceDomains: [
+    "https://fonts.googleapis.com",
+    "https://fonts.gstatic.com"
+  ]
+};
+registerAppResource(
+  server,
+  MARKDOWN_UI_URI,
+  MARKDOWN_UI_URI,
+  { mimeType: RESOURCE_MIME_TYPE, description: "Adeu Markdown Viewer UI" },
+  async () => {
+    let html = getAssetContent(
+      "templates",
+      "markdown_ui.html",
+      "<html><body>UI Template Not Found</body></html>"
+    );
+    const markedJs = getAssetContent(
+      "assets",
+      "marked.min.js",
+      "window.__MARKED_ERROR = 'marked.min.js not found';"
+    );
+    const svg = getAssetContent("assets", "adeu.svg", "");
+    html = html.replace("[[marked_js_code | safe]]", markedJs).replace("[[ adeu_svg_code ]]", svg);
+    return {
+      contents: [
+        {
+          uri: MARKDOWN_UI_URI,
+          mimeType: RESOURCE_MIME_TYPE,
+          text: html,
+          _meta: { ui: { csp: UI_CSP } }
+        }
+      ]
+    };
+  }
+);
+registerAppResource(
+  server,
+  EMAIL_UI_URI,
+  EMAIL_UI_URI,
+  { mimeType: RESOURCE_MIME_TYPE, description: "Adeu Email Viewer UI" },
+  async () => {
+    let html = getAssetContent(
+      "templates",
+      "email_ui.html",
+      "<html><body>UI Template Not Found</body></html>"
+    );
+    const svg = getAssetContent("assets", "adeu.svg", "");
+    html = html.replace("[[ adeu_svg_code ]]", svg);
+    return {
+      contents: [
+        {
+          uri: EMAIL_UI_URI,
+          mimeType: RESOURCE_MIME_TYPE,
+          text: html,
+          _meta: { ui: { csp: UI_CSP } }
+        }
+      ]
+    };
+  }
+);
+registerAppTool(
+  server,
+  "read_docx",
   {
-    name: "adeu-redlining-service",
-    version: "1.0.0"
+    title: "Read DOCX",
+    description: READ_DOCX_COMMON_DESC + READ_DOCX_TAIL,
+    inputSchema: z.object({
+      file_path: z.string().describe("Absolute path to the DOCX file."),
+      clean_view: z.boolean().default(false).describe(
+        "If False (default), returns the 'Raw' text with inline CriticMarkup. If True, returns 'Accepted' text."
+      ),
+      mode: z.enum(["full", "outline", "appendix"]).default("full").describe(
+        "'full' returns body content. 'outline' returns a structural heading map. 'appendix' returns defined terms."
+      ),
+      page: z.number().default(1).describe("Page number (1-indexed) for mode='full'. Defaults to 1."),
+      outline_max_level: z.number().default(2).describe("For mode='outline' only: cap on heading depth."),
+      outline_verbose: z.boolean().default(false).describe("For mode='outline' only: includes metadata.")
+    }),
+    _meta: { ui: { resourceUri: MARKDOWN_UI_URI } }
   },
+  async ({
+    file_path,
+    clean_view,
+    mode,
+    page,
+    outline_max_level,
+    outline_verbose
+  }) => {
+    try {
+      const buf = readFileBytesOrThrow(file_path);
+      const text = await extractTextFromBuffer(buf, clean_view);
+      if (mode === "outline") {
+        const doc = await DocumentObject2.load(buf);
+        return build_outline_response(
+          doc,
+          text,
+          file_path,
+          outline_max_level,
+          outline_verbose
+        );
+      }
+      if (mode === "appendix") {
+        return build_appendix_response(text, page, file_path);
+      }
+      return build_paginated_response(text, page, file_path);
+    } catch (e) {
+      return {
+        isError: true,
+        content: [
+          {
+            type: "text",
+            text: `Error executing tool read_docx: ${e.message}`
+          }
+        ]
+      };
+    }
+  }
+);
+registerAppTool(
+  server,
+  "search_and_fetch_emails",
   {
-    capabilities: {
-      tools: {}
+    title: "Search & Fetch Emails",
+    description: "Searches the user's live email inbox via the Adeu cloud backend.\n\nTWO MODES:\n1. Search mode (no `email_id`): returns up to `limit` lightweight previews. Use filters (`sender`, `subject`, `is_unread`, `days_ago`, `folder`, `has_attachments`, `attachment_name`) to narrow down.\n2. Fetch mode (with `email_id`): returns the full email body, thread history, and downloads attachments under `max_attachment_size_mb` to the local disk.\n\nAUTO-ESCALATION: If a search returns exactly one preview, the backend automatically fetches the full email in the same call. Plan around the response shape \u2014 check the `type` field (`previews` vs `full_email`) before assuming.\n\nEMAIL ID FORMATS (`email_id` parameter accepts any of):\n- `msg_<6 chars>` \u2014 short ID returned by previews on THIS machine. NOT portable across machines or sessions; the local cache holds the most recent 1000. If you reference one that's been evicted, the tool returns a StaleShortIdError telling you to re-search.\n- `adeu_<numeric>` \u2014 server-side reference for emails Adeu has previously processed. Portable across machines and sessions for the same authenticated user.\n- Raw provider ID (Gmail/Outlook native ID) \u2014 works if you have it, but you usually won't.\n\nFOLDER DEFAULT: omitting `folder` searches the Inbox only (matching what the user sees in their mail client). Use `folder='sent'` for sent items, `folder='all'` to include Deleted Items, Drafts, and other folders.\n\nATTACHMENTS: attachments larger than `max_attachment_size_mb` (default 10) are listed in the response but NOT downloaded \u2014 raise the cap if you need them. Always set `working_directory` when calling from a project so attachments land alongside the user's other files.",
+    inputSchema: z.object({
+      sender: z.string().optional(),
+      subject: z.string().optional(),
+      has_attachments: z.boolean().optional(),
+      attachment_name: z.string().optional(),
+      is_unread: z.boolean().optional(),
+      days_ago: z.number().optional(),
+      folder: z.enum(["inbox", "sent", "all"]).optional(),
+      limit: z.number().default(10),
+      offset: z.number().default(0),
+      email_id: z.string().optional(),
+      working_directory: z.string().optional(),
+      mailbox_address: z.string().optional().describe("Optional target mailbox email address to search within."),
+      max_attachment_size_mb: z.number().optional().describe(
+        "Maximum attachment size in MB to download (default 10). Attachments larger than this are listed in the response but not downloaded. Raise this to fetch large files."
+      )
+    }),
+    _meta: { ui: { resourceUri: EMAIL_UI_URI } }
+  },
+  async (args) => {
+    try {
+      return await search_and_fetch_emails(args);
+    } catch (e) {
+      return {
+        isError: true,
+        content: [{ type: "text", text: e.message }]
+      };
     }
   }
 );
-server.setRequestHandler(ListToolsRequestSchema, async () => {
-  return {
-    tools: [
-      {
-        name: "read_docx",
-        description: READ_DOCX_COMMON_DESC + READ_DOCX_TAIL,
-        inputSchema: {
-          type: "object",
-          properties: {
-            file_path: {
-              type: "string",
-              description: "Absolute path to the DOCX file."
-            },
-            clean_view: {
-              type: "boolean",
-              description: "If False (default), returns the 'Raw' text with inline CriticMarkup. If True, returns 'Accepted' text.",
-              default: false
-            },
-            mode: {
-              type: "string",
-              enum: ["full", "outline", "appendix"],
-              description: "'full' returns body content. 'outline' returns a structural heading map. 'appendix' returns defined terms.",
-              default: "full"
-            },
-            page: {
-              type: "number",
-              description: "Page number (1-indexed) for mode='full'. Defaults to 1.",
-              default: 1
-            },
-            outline_max_level: {
-              type: "number",
-              description: "For mode='outline' only: cap on heading depth.",
-              default: 2
-            },
-            outline_verbose: {
-              type: "boolean",
-              description: "For mode='outline' only: includes metadata.",
-              default: false
-            }
-          },
-          required: ["file_path"]
-        }
-      },
-      {
-        name: "process_document_batch",
-        description: PROCESS_BATCH_COMMON_DESC + PROCESS_BATCH_OPERATIONS_DESC,
-        inputSchema: {
-          type: "object",
-          properties: {
-            original_docx_path: {
-              type: "string",
-              description: "Absolute path to the source file."
-            },
-            author_name: {
-              type: "string",
-              description: "Name to appear in Track Changes (e.g., 'Reviewer AI')."
-            },
-            changes: {
-              type: "array",
-              description: "List of changes to apply. Each change must specify 'type'.",
-              items: { type: "object" }
-            },
-            output_path: {
-              type: "string",
-              description: "Optional output path."
-            }
-          },
-          required: ["original_docx_path", "author_name", "changes"]
-        }
-      },
-      {
-        name: "accept_all_changes",
-        description: "Accepts all tracked changes and removes all comments in a single operation, producing a finalized clean document. Use this when a document review is entirely complete and you want to clear all redlines.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            docx_path: {
-              type: "string",
-              description: "Absolute path to the DOCX file."
-            },
-            output_path: {
-              type: "string",
-              description: "Optional output path."
-            }
-          },
-          required: ["docx_path"]
-        }
-      },
-      {
-        name: "diff_docx_files",
-        description: DIFF_DOCX_DESC,
-        inputSchema: {
-          type: "object",
-          properties: {
-            original_path: {
-              type: "string",
-              description: "Absolute path to the baseline DOCX file."
-            },
-            modified_path: {
-              type: "string",
-              description: "Absolute path to the modified DOCX file."
-            },
-            compare_clean: {
-              type: "boolean",
-              description: "If True, compares 'Accepted' state. If False, compares raw text.",
-              default: true
-            }
-          },
-          required: ["original_path", "modified_path"]
-        }
-      },
-      {
-        name: "finalize_document",
-        description: "Prepares a document for external distribution or e-signature. This tool combines metadata sanitization, document locking (protection), and markup resolution into a single step. NOTE: PDF export and AES encryption are disabled in this environment.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            file_path: {
-              type: "string",
-              description: "Absolute path to the DOCX file."
-            },
-            output_path: {
-              type: "string",
-              description: "Optional output path."
-            },
-            sanitize_mode: {
-              type: "string",
-              enum: ["full", "keep-markup"],
-              description: "full removes all markup, keep-markup redacts metadata but keeps comments/redlines."
-            },
-            accept_all: {
-              type: "boolean",
-              description: "If true, auto-accepts all unresolved track changes before finalizing."
-            },
-            protection_mode: {
-              type: "string",
-              enum: ["read_only", "encrypt"],
-              description: "Native OOXML document locking. encrypt falls back to read_only in this environment."
-            },
-            password: {
-              type: "string",
-              description: "Ignored in this environment."
-            },
-            author: {
-              type: "string",
-              description: "Replace all remaining markup authorship with this name."
-            },
-            export_pdf: {
-              type: "boolean",
-              description: "Ignored in this environment."
-            }
-          },
-          required: ["file_path"]
-        }
-      },
-      {
-        name: "login_to_adeu_cloud",
-        description: "Logs the user into the Adeu Cloud backend. Securely opens a browser window for authentication.",
-        inputSchema: { type: "object", properties: {} }
-      },
-      {
-        name: "logout_of_adeu_cloud",
-        description: "Logs out of the Adeu Cloud backend by clearing the local API key.",
-        inputSchema: { type: "object", properties: {} }
-      },
-      {
-        name: "search_and_fetch_emails",
-        description: "Searches the user's live email inbox. By default, searches only the Inbox folder. Returns a list of lightweight previews. Call again with `email_id` to fetch the full body and download attachments.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            sender: { type: "string" },
-            subject: { type: "string" },
-            has_attachments: { type: "boolean" },
-            attachment_name: { type: "string" },
-            is_unread: { type: "boolean" },
-            days_ago: { type: "number" },
-            folder: { type: "string", enum: ["inbox", "sent", "all"] },
-            limit: { type: "number", default: 10 },
-            offset: { type: "number", default: 0 },
-            email_id: { type: "string" },
-            working_directory: { type: "string" }
-          }
-        }
-      },
-      {
-        name: "create_email_draft",
-        description: "Creates an email draft in the user's native draft box. Provide `reply_to_email_id` to reply, or `subject` and `to_recipients` for a new email.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            body_markdown: { type: "string" },
-            reply_to_email_id: { type: "string" },
-            subject: { type: "string" },
-            to_recipients: { type: "array", items: { type: "string" } },
-            attachment_paths: { type: "array", items: { type: "string" } }
-          },
-          required: ["body_markdown"]
-        }
-      }
-    ]
-  };
-});
-server.setRequestHandler(
-  CallToolRequestSchema,
-  async (request) => {
-    const { name, arguments: args } = request.params;
+server.registerTool(
+  "process_document_batch",
+  {
+    description: PROCESS_BATCH_COMMON_DESC + PROCESS_BATCH_OPERATIONS_DESC,
+    inputSchema: {
+      original_docx_path: z.string().describe("Absolute path to the source file."),
+      author_name: z.string().describe("Name to appear in Track Changes (e.g., 'Reviewer AI')."),
+      changes: z.array(z.any()).describe("List of changes to apply. Each change must specify 'type'."),
+      output_path: z.string().optional().describe("Optional output path."),
+      dry_run: z.boolean().optional().default(false).describe("If True, simulates the changes and returns a detailed preview report without modifying any files.")
+    }
+  },
+  async ({ original_docx_path, author_name, changes, output_path, dry_run }) => {
     try {
-      if (name === "read_docx") {
-        const filePath = args?.file_path;
-        const cleanView = args?.clean_view ?? false;
-        const mode = args?.mode ?? "full";
-        const page = args?.page ?? 1;
-        const outline_max_level = args?.outline_max_level ?? 2;
-        const outline_verbose = args?.outline_verbose ?? false;
-        const buf = readFileBytesOrThrow(filePath);
-        const text = await extractTextFromBuffer(buf, cleanView);
-        if (mode === "outline") {
-          const doc = await DocumentObject2.load(buf);
-          return build_outline_response(
-            doc,
-            text,
-            filePath,
-            outline_max_level,
-            outline_verbose
-          );
-        }
-        if (mode === "appendix") {
-          return build_appendix_response(text, page, filePath);
-        }
-        return build_paginated_response(text, page, filePath);
-      }
-      if (name === "process_document_batch") {
-        const origPath = args?.original_docx_path;
-        const authorName = args?.author_name;
-        const changes = args?.changes;
-        let outPath = args?.output_path;
-        if (!authorName || !authorName.trim()) {
-          return {
-            content: [
-              { type: "text", text: "Error: author_name cannot be empty." }
-            ]
-          };
-        }
-        if (!changes || changes.length === 0) {
-          return {
-            content: [{ type: "text", text: "Error: No changes provided." }]
-          };
-        }
-        if (!outPath) {
-          const ext = extname(origPath);
-          const base = basename2(origPath, ext);
-          const dir = dirname(origPath);
-          outPath = resolve2(dir, `${base}_processed${ext}`);
-        }
-        const buf = readFileBytesOrThrow(origPath);
-        const doc = await DocumentObject2.load(buf);
-        const engine = new RedlineEngine(doc, authorName);
-        let stats;
-        try {
-          stats = engine.process_batch(changes);
-        } catch (e) {
-          if (e instanceof BatchValidationError) {
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: `Batch rejected. Some edits failed validation:
-
-${e.errors.join("\n\n")}`
-                }
-              ],
-              isError: true
-            };
-          }
-          throw e;
-        }
-        const outBuf = await doc.save();
-        const fs = await import("fs");
-        fs.writeFileSync(outPath, outBuf);
-        let res = `Batch complete. Saved to: ${outPath}
-Actions: ${stats.actions_applied} applied, ${stats.actions_skipped} skipped.
-Edits: ${stats.edits_applied} applied, ${stats.edits_skipped} skipped.`;
-        if (stats.skipped_details?.length > 0) {
-          res += `
-
-Skipped Details:
-${stats.skipped_details.join("\n")}`;
-        }
-        return {
-          content: [{ type: "text", text: res }]
-        };
-      }
-      if (name === "accept_all_changes") {
-        const docxPath = args?.docx_path;
-        let outPath = args?.output_path;
-        if (!outPath) {
-          const ext = extname(docxPath);
-          const base = basename2(docxPath, ext);
-          const dir = dirname(docxPath);
-          outPath = resolve2(dir, `${base}_clean${ext}`);
-        }
-        const buf = readFileBytesOrThrow(docxPath);
-        const doc = await DocumentObject2.load(buf);
-        const engine = new RedlineEngine(doc);
-        engine.accept_all_revisions();
-        const outBuf = await doc.save();
-        const fs = await import("fs");
-        fs.writeFileSync(outPath, outBuf);
+      if (!author_name || !author_name.trim())
         return {
           content: [
-            {
-              type: "text",
-              text: `Accepted all changes. Saved to: ${outPath}`
-            }
+            { type: "text", text: "Error: author_name cannot be empty." }
           ]
         };
-      }
-      if (name === "diff_docx_files") {
-        const origPath = args?.original_path;
-        const modPath = args?.modified_path;
-        const compareClean = args?.compare_clean ?? true;
-        const origBuf = readFileBytesOrThrow(origPath);
-        const modBuf = readFileBytesOrThrow(modPath);
-        const origText = await extractTextFromBuffer(origBuf, compareClean);
-        const modText = await extractTextFromBuffer(modBuf, compareClean);
-        const diff = create_word_patch_diff(
-          origText,
-          modText,
-          basename2(origPath),
-          basename2(modPath)
-        );
+      if (!changes || changes.length === 0)
         return {
-          content: [{ type: "text", text: diff || "No differences found." }]
+          content: [{ type: "text", text: "Error: No changes provided." }]
         };
+      let outPath = output_path;
+      if (!outPath) {
+        const ext = extname(original_docx_path);
+        const base = basename2(original_docx_path, ext);
+        const dir = dirname(original_docx_path);
+        outPath = resolve2(dir, `${base}_processed${ext}`);
       }
-      if (name === "finalize_document") {
-        const filePath = args?.file_path;
-        let outPath = args?.output_path;
-        if (!outPath) {
-          const ext = extname(filePath);
-          const base = basename2(filePath, ext);
-          const dir = dirname(filePath);
-          outPath = resolve2(dir, `${base}_final${ext}`);
-        }
-        const buf = readFileBytesOrThrow(filePath);
-        const doc = await DocumentObject2.load(buf);
-        const result = await finalize_document(doc, {
-          filename: basename2(filePath),
-          sanitize_mode: args?.sanitize_mode || "full",
-          accept_all: args?.accept_all,
-          protection_mode: args?.protection_mode,
-          author: args?.author,
-          export_pdf: args?.export_pdf
-        });
-        const fs = await import("fs");
-        fs.writeFileSync(outPath, result.outBuffer);
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Saved to: ${outPath}
+      const buf = readFileBytesOrThrow(original_docx_path);
+      const doc = await DocumentObject2.load(buf);
+      const engine = new RedlineEngine(doc, author_name);
+      let stats;
+      try {
+        stats = engine.process_batch(changes, dry_run);
+      } catch (e) {
+        if (e instanceof BatchValidationError) {
+          return {
+            isError: true,
+            content: [
+              {
+                type: "text",
+                text: `Batch rejected. Some edits failed validation:
 
-${result.reportText}`
-            }
-          ]
-        };
-      }
-      if (name === "login_to_adeu_cloud") {
-        return await login_to_adeu_cloud();
+${e.errors.join("\n\n")}`
+              }
+            ]
+          };
+        }
+        throw e;
       }
-      if (name === "logout_of_adeu_cloud") {
-        return await logout_of_adeu_cloud();
+      if (!dry_run) {
+        const outBuf = await doc.save();
+        fs.writeFileSync(outPath, outBuf);
       }
-      if (name === "search_and_fetch_emails") {
-        return await search_and_fetch_emails(args || {});
+      const res = formatBatchResult(stats, outPath, !!dry_run);
+      return { content: [{ type: "text", text: res }] };
+    } catch (e) {
+      return {
+        isError: true,
+        content: [{ type: "text", text: `Error: ${e.message}` }]
+      };
+    }
+  }
+);
+server.registerTool(
+  "accept_all_changes",
+  {
+    description: "Accepts all tracked changes and removes all comments in a single operation.",
+    inputSchema: {
+      docx_path: z.string().describe("Absolute path to the DOCX file."),
+      output_path: z.string().optional().describe("Optional output path.")
+    }
+  },
+  async ({ docx_path, output_path }) => {
+    try {
+      let outPath = output_path;
+      if (!outPath) {
+        const ext = extname(docx_path);
+        const base = basename2(docx_path, ext);
+        const dir = dirname(docx_path);
+        outPath = resolve2(dir, `${base}_clean${ext}`);
       }
-      if (name === "create_email_draft") {
-        return await create_email_draft(args || {});
+      const buf = readFileBytesOrThrow(docx_path);
+      const doc = await DocumentObject2.load(buf);
+      const engine = new RedlineEngine(doc);
+      engine.accept_all_revisions();
+      const outBuf = await doc.save();
+      fs.writeFileSync(outPath, outBuf);
+      return {
+        content: [
+          { type: "text", text: `Accepted all changes. Saved to: ${outPath}` }
+        ]
+      };
+    } catch (e) {
+      return {
+        isError: true,
+        content: [{ type: "text", text: `Error: ${e.message}` }]
+      };
+    }
+  }
+);
+server.registerTool(
+  "diff_docx_files",
+  {
+    description: DIFF_DOCX_DESC,
+    inputSchema: {
+      original_path: z.string().describe("Absolute path to the baseline DOCX file."),
+      modified_path: z.string().describe("Absolute path to the modified DOCX file."),
+      compare_clean: z.boolean().default(true).describe(
+        "If True, compares 'Accepted' state. If False, compares raw text."
+      )
+    }
+  },
+  async ({ original_path, modified_path, compare_clean }) => {
+    try {
+      const origBuf = readFileBytesOrThrow(original_path);
+      const modBuf = readFileBytesOrThrow(modified_path);
+      const origText = await extractTextFromBuffer(origBuf, compare_clean);
+      const modText = await extractTextFromBuffer(modBuf, compare_clean);
+      const diff = create_word_patch_diff(
+        origText,
+        modText,
+        basename2(original_path),
+        basename2(modified_path)
+      );
+      return {
+        content: [{ type: "text", text: diff || "No differences found." }]
+      };
+    } catch (e) {
+      return {
+        isError: true,
+        content: [{ type: "text", text: `Error: ${e.message}` }]
+      };
+    }
+  }
+);
+server.registerTool(
+  "finalize_document",
+  {
+    description: "Prepares a document for external distribution or e-signature.",
+    inputSchema: {
+      file_path: z.string().describe("Absolute path to the DOCX file."),
+      output_path: z.string().optional().describe("Optional output path."),
+      sanitize_mode: z.enum(["full", "keep-markup"]).optional().describe("full removes all markup, keep-markup redacts metadata."),
+      accept_all: z.boolean().optional().describe(
+        "If true, auto-accepts all unresolved track changes before finalizing."
+      ),
+      protection_mode: z.enum(["read_only", "encrypt"]).optional().describe("Native OOXML document locking."),
+      password: z.string().optional().describe("Ignored in this environment."),
+      author: z.string().optional().describe("Replace all remaining markup authorship with this name."),
+      export_pdf: z.boolean().optional().describe("Ignored in this environment.")
+    }
+  },
+  async ({
+    file_path,
+    output_path,
+    sanitize_mode,
+    accept_all,
+    protection_mode,
+    author,
+    export_pdf
+  }) => {
+    try {
+      let outPath = output_path;
+      if (!outPath) {
+        const ext = extname(file_path);
+        const base = basename2(file_path, ext);
+        const dir = dirname(file_path);
+        outPath = resolve2(dir, `${base}_final${ext}`);
       }
-      throw new Error(`Unknown tool: ${name}`);
-    } catch (error) {
+      const buf = readFileBytesOrThrow(file_path);
+      const doc = await DocumentObject2.load(buf);
+      const result = await finalize_document(doc, {
+        filename: basename2(file_path),
+        sanitize_mode: sanitize_mode || "full",
+        accept_all,
+        protection_mode,
+        author,
+        export_pdf
+      });
+      fs.writeFileSync(outPath, result.outBuffer);
       return {
         content: [
           {
             type: "text",
-            text: `Error executing tool ${name}: ${error.message}`
+            text: `Saved to: ${outPath}
+
+${result.reportText}`
           }
-        ],
-        isError: true
+        ]
+      };
+    } catch (e) {
+      return {
+        isError: true,
+        content: [{ type: "text", text: `Error: ${e.message}` }]
       };
     }
   }
 );
+server.registerTool(
+  "login_to_adeu_cloud",
+  { description: "Logs the user into the Adeu Cloud backend." },
+  async () => {
+    try {
+      return await login_to_adeu_cloud();
+    } catch (e) {
+      return { isError: true, content: [{ type: "text", text: e.message }] };
+    }
+  }
+);
+server.registerTool(
+  "logout_of_adeu_cloud",
+  { description: "Logs out of the Adeu Cloud backend." },
+  async () => {
+    try {
+      return await logout_of_adeu_cloud();
+    } catch (e) {
+      return { isError: true, content: [{ type: "text", text: e.message }] };
+    }
+  }
+);
+server.registerTool(
+  "create_email_draft",
+  {
+    description: "Creates an email draft in the user's native draft box (Outlook Drafts or Gmail Drafts).\n\nTWO MODES:\n1. Reply mode: pass `reply_to_email_id` to create a threaded reply. The draft inherits subject, recipients, and threading headers from the original \u2014 do NOT pass `subject` or `to_recipients`.\n2. New email mode: omit `reply_to_email_id` and pass BOTH `subject` and `to_recipients`.\n\n`reply_to_email_id` accepts the same ID formats as search_and_fetch_emails (`msg_*` short IDs, `adeu_*` references, or raw provider IDs). Short IDs are validated against the local cache before the call; stale ones fail fast with a clear error telling you to re-search.\n\n`body_markdown` is converted server-side to styled HTML with inlined CSS for email-client compatibility. Write the body in plain Markdown \u2014 do not pre-render HTML.\n\n`attachment_paths` takes absolute file paths on the user's local disk and uploads them with the draft. Useful right after search_and_fetch_emails downloaded attachments \u2014 those local paths can be passed directly here.",
+    inputSchema: {
+      body_markdown: z.string(),
+      reply_to_email_id: z.string().optional(),
+      subject: z.string().optional(),
+      to_recipients: z.array(z.string()).optional(),
+      attachment_paths: z.array(z.string()).optional(),
+      mailbox_address: z.string().optional().describe(
+        "Optional target mailbox email address to create the draft in."
+      )
+    }
+  },
+  async (args) => {
+    try {
+      return await create_email_draft(args);
+    } catch (e) {
+      return { isError: true, content: [{ type: "text", text: e.message }] };
+    }
+  }
+);
+server.registerTool(
+  "list_available_mailboxes",
+  {
+    description: "Lists all personal and shared delegated mailboxes the authenticated user has access to. Returns each mailbox's `email_address`, `display_name`, auto-processing settings, and write-back preference.\n\nCall this FIRST when the user mentions a specific mailbox or shared inbox by name, to resolve the canonical `email_address`. Then pass that address as `mailbox_address` to `search_and_fetch_emails` or `create_email_draft` to scope the operation.\n\nOmitting `mailbox_address` on those tools targets the user's primary personal mailbox.",
+    inputSchema: {}
+  },
+  async () => {
+    try {
+      return await list_available_mailboxes();
+    } catch (e) {
+      return { isError: true, content: [{ type: "text", text: e.message }] };
+    }
+  }
+);
+function formatBatchResult(stats, outPath, dry_run) {
+  let res = "";
+  if (dry_run) {
+    res = `Dry-run simulation complete.
+`;
+  } else {
+    res = `Batch complete. Saved to: ${outPath}
+`;
+  }
+  res += `Actions: ${stats.actions_applied} applied, ${stats.actions_skipped} skipped.
+`;
+  res += `Edits: ${stats.edits_applied} applied, ${stats.edits_skipped} skipped.
+`;
+  if (stats.edits && stats.edits.length > 0) {
+    res += "\nDetailed Edit Reports:\n";
+    for (let i = 0; i < stats.edits.length; i++) {
+      const report = stats.edits[i];
+      const status_indicator = report.status === "applied" ? "\u2705 [applied]" : "\u274C [failed]";
+      res += `Edit ${i + 1} ${status_indicator}:
+`;
+      res += `  Target: '${report.target_text}'
+`;
+      res += `  New text: '${report.new_text}'
+`;
+      if (report.warning) {
+        res += `  Warning: ${report.warning}
+`;
+      }
+      if (report.error) {
+        res += `  Error: ${report.error}
+`;
+      }
+      if (report.critic_markup) {
+        res += `  Preview (CriticMarkup): ${report.critic_markup}
+`;
+      }
+      if (report.clean_text) {
+        res += `  Clean text preview: ${report.clean_text}
+`;
+      }
+    }
+  }
+  if (stats.skipped_details && stats.skipped_details.length > 0) {
+    res += `
+
+Skipped Details:
+${stats.skipped_details.join("\n")}`;
+  }
+  return res;
+}
 async function main() {
   const transport = new StdioServerTransport();
   await server.connect(transport);
@@ -1023,4 +1477,7 @@ async function main() {
   );
 }
 main().catch(console.error);
+export {
+  formatBatchResult
+};
 //# sourceMappingURL=index.js.map