@agenticmail/mcp 0.5.49 → 0.5.51

package/dist/index.js

@@ -3,6 +3,7 @@
 // src/index.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 
 // src/pending-followup.ts
 var STEP_DELAYS_MS = [
@@ -1064,22 +1065,22 @@ function mcpBuildSecuritySection(security, attachments) {
 --- Security ---
 ${lines.join("\n")}`;
 }
-async function handleToolCall(name, args) {
+async function handleToolCall(name, args2) {
   recordToolCall(name);
   const useMaster = MASTER_KEY_TOOLS.has(name);
   switch (name) {
     case "send_email": {
       const sendBody = {
-        to: args.to,
-        subject: args.subject,
-        text: args.text ?? "",
-        html: args.html,
-        cc: args.cc,
-        inReplyTo: args.inReplyTo,
-        references: args.references
+        to: args2.to,
+        subject: args2.subject,
+        text: args2.text ?? "",
+        html: args2.html,
+        cc: args2.cc,
+        inReplyTo: args2.inReplyTo,
+        references: args2.references
       };
-      if (Array.isArray(args.attachments) && args.attachments.length > 0) {
-        sendBody.attachments = args.attachments.map((a) => ({
+      if (Array.isArray(args2.attachments) && args2.attachments.length > 0) {
+        sendBody.attachments = args2.attachments.map((a) => ({
           filename: a.filename,
           content: a.content,
           contentType: a.contentType,
@@ -1088,7 +1089,7 @@ async function handleToolCall(name, args) {
       }
       const result = await apiRequest("POST", "/mail/send", sendBody);
       if (result?.blocked && result?.pendingId) {
-        scheduleFollowUp(result.pendingId, String(args.to), String(args.subject || "(no subject)"), makePendingCheck(result.pendingId));
+        scheduleFollowUp(result.pendingId, String(args2.to), String(args2.subject || "(no subject)"), makePendingCheck(result.pendingId));
         return `Email NOT sent \u2014 blocked by outbound guard.
 ${result.summary}
 
@@ -1112,8 +1113,8 @@ ${result.outboundWarnings.map((w) => `  [${w.severity?.toUpperCase()}] ${w.descr
       return response;
     }
     case "list_inbox": {
-      const limit = Math.min(Math.max(Number(args.limit) || 20, 1), 100);
-      const offset = Math.max(Number(args.offset) || 0, 0);
+      const limit = Math.min(Math.max(Number(args2.limit) || 20, 1), 100);
+      const offset = Math.max(Number(args2.offset) || 0, 0);
       const result = await apiRequest("GET", `/mail/inbox?limit=${limit}&offset=${offset}`);
       if (!result?.messages?.length) {
         return "Inbox is empty.";
@@ -1125,7 +1126,7 @@ ${result.outboundWarnings.map((w) => `  [${w.severity?.toUpperCase()}] ${w.descr
 ${lines.join("\n")}`;
     }
     case "read_email": {
-      const uid = Number(args.uid);
+      const uid = Number(args2.uid);
       if (!uid || uid < 1 || !Number.isInteger(uid)) {
         throw new Error("uid must be a positive integer");
       }
@@ -1153,7 +1154,7 @@ ${lines.join("\n")}`;
       return lines.filter((line) => line !== null).join("\n");
     }
     case "delete_email": {
-      const uid = Number(args.uid);
+      const uid = Number(args2.uid);
       if (!uid || uid < 1 || !Number.isInteger(uid)) {
         throw new Error("uid must be a positive integer");
       }
@@ -1161,7 +1162,7 @@ ${lines.join("\n")}`;
       return `Email UID ${uid} deleted successfully.`;
     }
     case "search_emails": {
-      const { from, to, subject, text, since, before, seen, searchRelay } = args;
+      const { from, to, subject, text, since, before, seen, searchRelay } = args2;
       const result = await apiRequest("POST", "/mail/search", { from, to, subject, text, since, before, seen, searchRelay });
       const lines = [];
       if (result?.uids?.length) {
@@ -1183,7 +1184,7 @@ Connected account (${result.relayResults[0].account}): ${result.relayResults.len
       return lines.join("\n");
     }
     case "import_relay_email": {
-      const uid = Number(args.uid);
+      const uid = Number(args2.uid);
       if (!uid || uid < 1 || !Number.isInteger(uid)) {
         throw new Error("uid must be a positive integer (relay UID from search results)");
       }
@@ -1191,7 +1192,7 @@ Connected account (${result.relayResults[0].account}): ${result.relayResults.len
       return result?.ok ? "Email imported to local inbox. You can now use list_inbox to find it and reply_email to continue the thread." : `Import failed: ${result?.error || "unknown error"}`;
     }
     case "reply_email": {
-      const uid = Number(args.uid);
+      const uid = Number(args2.uid);
       if (!uid || uid < 1) throw new Error("uid must be a positive integer");
       const original = await apiRequest("GET", `/mail/messages/${uid}`);
       if (!original) throw new Error("Original email not found");
@@ -1202,12 +1203,12 @@ Connected account (${result.relayResults[0].account}): ${result.relayResults.len
       const refs = Array.isArray(original.references) ? [...original.references] : [];
       if (original.messageId) refs.push(original.messageId);
       const quotedBody = (original.text || "").split("\n").map((l) => `> ${l}`).join("\n");
-      const fullText = `${args.text}
+      const fullText = `${args2.text}
 
 On ${original.date}, ${replyTo} wrote:
 ${quotedBody}`;
       let to = replyTo;
-      if (args.replyAll) {
+      if (args2.replyAll) {
         const allTo = [...original.to || [], ...original.cc || []].map((a) => a.address).filter(Boolean);
         to = [replyTo, ...allTo].filter((v, i, a) => v && a.indexOf(v) === i).join(", ");
       }
@@ -1215,7 +1216,7 @@ ${quotedBody}`;
         to,
         subject,
         text: fullText,
-        html: args.html,
+        html: args2.html,
         inReplyTo: original.messageId,
         references: refs
       };
@@ -1244,21 +1245,21 @@ ${sendResult.outboundWarnings.map((w) => `  [${w.severity?.toUpperCase()}] ${w.d
       return response;
     }
     case "forward_email": {
-      const uid = Number(args.uid);
+      const uid = Number(args2.uid);
       if (!uid || uid < 1) throw new Error("uid must be a positive integer");
       const orig = await apiRequest("GET", `/mail/messages/${uid}`);
       if (!orig) throw new Error("Email not found");
       const fwdSubject = (orig.subject ?? "").startsWith("Fwd:") ? orig.subject : `Fwd: ${orig.subject}`;
       const origFrom = orig.from?.[0]?.address ?? "unknown";
       const origTo = (orig.to || []).map((a) => a.address).join(", ");
-      const fwdBody = `${args.text ? args.text + "\n\n" : ""}---------- Forwarded message ----------
+      const fwdBody = `${args2.text ? args2.text + "\n\n" : ""}---------- Forwarded message ----------
 From: ${origFrom}
 To: ${origTo}
 Date: ${orig.date}
 Subject: ${orig.subject}
 
 ${orig.text || ""}`;
-      const fwdSendBody = { to: args.to, subject: fwdSubject, text: fwdBody };
+      const fwdSendBody = { to: args2.to, subject: fwdSubject, text: fwdBody };
       if (Array.isArray(orig.attachments) && orig.attachments.length > 0) {
         fwdSendBody.attachments = orig.attachments.map((a) => ({
           filename: a.filename,
@@ -1269,7 +1270,7 @@ ${orig.text || ""}`;
       }
       const fwdResult = await apiRequest("POST", "/mail/send", fwdSendBody);
       if (fwdResult?.blocked && fwdResult?.pendingId) {
-        scheduleFollowUp(fwdResult.pendingId, String(args.to), fwdSubject, makePendingCheck(fwdResult.pendingId));
+        scheduleFollowUp(fwdResult.pendingId, String(args2.to), fwdSubject, makePendingCheck(fwdResult.pendingId));
         return `Forward NOT sent \u2014 blocked by outbound guard.
 ${fwdResult.summary}
 
@@ -1282,7 +1283,7 @@ You MUST now:
 3. If this forward is urgent or has a deadline, tell your owner about the time sensitivity.
 4. Periodically check with manage_pending_emails(action='list') and follow up with your owner if still pending.`;
       }
-      let response = `Forwarded to ${args.to}. Message ID: ${fwdResult?.messageId ?? "unknown"}`;
+      let response = `Forwarded to ${args2.to}. Message ID: ${fwdResult?.messageId ?? "unknown"}`;
       if (fwdResult?.outboundWarnings?.length) {
         response += `
 
@@ -1292,19 +1293,19 @@ ${fwdResult.outboundWarnings.map((w) => `  [${w.severity?.toUpperCase()}] ${w.de
       return response;
     }
     case "move_email": {
-      const uid = Number(args.uid);
+      const uid = Number(args2.uid);
       if (!uid || uid < 1) throw new Error("uid must be a positive integer");
-      await apiRequest("POST", `/mail/messages/${uid}/move`, { from: args.from || "INBOX", to: args.to });
-      return `Moved message UID ${uid} to ${args.to}`;
+      await apiRequest("POST", `/mail/messages/${uid}/move`, { from: args2.from || "INBOX", to: args2.to });
+      return `Moved message UID ${uid} to ${args2.to}`;
     }
     case "mark_unread": {
-      const uid = Number(args.uid);
+      const uid = Number(args2.uid);
       if (!uid || uid < 1) throw new Error("uid must be a positive integer");
       await apiRequest("POST", `/mail/messages/${uid}/unseen`);
       return `Marked message UID ${uid} as unread`;
     }
     case "mark_read": {
-      const uid = Number(args.uid);
+      const uid = Number(args2.uid);
       if (!uid || uid < 1) throw new Error("uid must be a positive integer");
       await apiRequest("POST", `/mail/messages/${uid}/seen`);
       return `Marked message UID ${uid} as read`;
@@ -1315,74 +1316,74 @@ ${fwdResult.outboundWarnings.map((w) => `  [${w.severity?.toUpperCase()}] ${w.de
       return result.folders.map((f) => `${f.path}${f.specialUse ? ` (${f.specialUse})` : ""}`).join("\n");
     }
     case "list_folder": {
-      const folder = encodeURIComponent(String(args.folder));
-      const limit = Math.min(Math.max(Number(args.limit) || 20, 1), 100);
-      const offset = Math.max(Number(args.offset) || 0, 0);
+      const folder = encodeURIComponent(String(args2.folder));
+      const limit = Math.min(Math.max(Number(args2.limit) || 20, 1), 100);
+      const offset = Math.max(Number(args2.offset) || 0, 0);
       const result = await apiRequest("GET", `/mail/folders/${folder}?limit=${limit}&offset=${offset}`);
-      if (!result?.messages?.length) return `Folder "${args.folder}" is empty.`;
+      if (!result?.messages?.length) return `Folder "${args2.folder}" is empty.`;
       const lines = result.messages.map((m, i) => `${i + 1}. [UID:${m.uid}] From: ${m.from?.[0]?.address ?? "unknown"} | Subject: ${m.subject} | Date: ${m.date}`);
-      return `${args.folder} (${result.total} total):
+      return `${args2.folder} (${result.total} total):
 ${lines.join("\n")}`;
     }
     case "batch_delete": {
-      const uids = args.uids;
+      const uids = args2.uids;
       if (!Array.isArray(uids) || uids.length === 0) throw new Error("uids array required");
-      await apiRequest("POST", "/mail/batch/delete", { uids, folder: args.folder });
+      await apiRequest("POST", "/mail/batch/delete", { uids, folder: args2.folder });
       return `Deleted ${uids.length} messages.`;
     }
     case "batch_mark_read": {
-      const uids = args.uids;
+      const uids = args2.uids;
       if (!Array.isArray(uids) || uids.length === 0) throw new Error("uids array required");
-      await apiRequest("POST", "/mail/batch/seen", { uids, folder: args.folder });
+      await apiRequest("POST", "/mail/batch/seen", { uids, folder: args2.folder });
       return `Marked ${uids.length} messages as read.`;
     }
     case "manage_contacts": {
-      if (args.action === "list") {
+      if (args2.action === "list") {
         const r = await apiRequest("GET", "/contacts");
         if (!r?.contacts?.length) return "No contacts.";
         return r.contacts.map((c) => `${c.name || "(no name)"} <${c.email}>`).join("\n");
       }
-      if (args.action === "add") {
-        if (!args.email) throw new Error("email is required");
-        await apiRequest("POST", "/contacts", { email: args.email, name: args.name });
-        return `Contact added: ${args.name || ""} <${args.email}>`;
+      if (args2.action === "add") {
+        if (!args2.email) throw new Error("email is required");
+        await apiRequest("POST", "/contacts", { email: args2.email, name: args2.name });
+        return `Contact added: ${args2.name || ""} <${args2.email}>`;
       }
-      if (args.action === "delete") {
-        if (!args.id) throw new Error("id is required");
-        await apiRequest("DELETE", `/contacts/${args.id}`);
+      if (args2.action === "delete") {
+        if (!args2.id) throw new Error("id is required");
+        await apiRequest("DELETE", `/contacts/${args2.id}`);
         return "Contact deleted.";
       }
       throw new Error("Invalid action");
     }
     case "manage_drafts": {
-      if (args.action === "list") {
+      if (args2.action === "list") {
         const r = await apiRequest("GET", "/drafts");
         if (!r?.drafts?.length) return "No drafts.";
         return r.drafts.map((d) => `[${d.id}] To: ${d.to_addr || "?"} | Subject: ${d.subject || "?"}`).join("\n");
       }
-      if (args.action === "create") {
-        const r = await apiRequest("POST", "/drafts", { to: args.to, subject: args.subject, text: args.text });
+      if (args2.action === "create") {
+        const r = await apiRequest("POST", "/drafts", { to: args2.to, subject: args2.subject, text: args2.text });
         return `Draft created: ${r?.id}`;
       }
-      if (args.action === "update") {
-        if (!args.id) throw new Error("id is required");
-        await apiRequest("PUT", `/drafts/${args.id}`, { to: args.to, subject: args.subject, text: args.text });
-        return `Draft ${args.id} updated.`;
+      if (args2.action === "update") {
+        if (!args2.id) throw new Error("id is required");
+        await apiRequest("PUT", `/drafts/${args2.id}`, { to: args2.to, subject: args2.subject, text: args2.text });
+        return `Draft ${args2.id} updated.`;
       }
-      if (args.action === "send") {
-        if (!args.id) throw new Error("id is required");
-        const r = await apiRequest("POST", `/drafts/${args.id}/send`);
+      if (args2.action === "send") {
+        if (!args2.id) throw new Error("id is required");
+        const r = await apiRequest("POST", `/drafts/${args2.id}/send`);
         return `Draft sent. Message ID: ${r?.messageId ?? "unknown"}`;
       }
-      if (args.action === "delete") {
-        if (!args.id) throw new Error("id is required");
-        await apiRequest("DELETE", `/drafts/${args.id}`);
+      if (args2.action === "delete") {
+        if (!args2.id) throw new Error("id is required");
+        await apiRequest("DELETE", `/drafts/${args2.id}`);
         return "Draft deleted.";
       }
       throw new Error("Invalid action");
     }
     case "manage_scheduled": {
-      const action = args.action || "create";
+      const action = args2.action || "create";
       if (action === "list") {
         const r2 = await apiRequest("GET", "/scheduled");
         if (!r2?.scheduled?.length) return "No scheduled emails.";
@@ -1391,61 +1392,61 @@ ${lines.join("\n")}`;
         ).join("\n");
       }
       if (action === "cancel") {
-        if (!args.id) throw new Error("id is required");
-        await apiRequest("DELETE", `/scheduled/${args.id}`);
+        if (!args2.id) throw new Error("id is required");
+        await apiRequest("DELETE", `/scheduled/${args2.id}`);
         return "Scheduled email cancelled.";
       }
       const r = await apiRequest("POST", "/scheduled", {
-        to: args.to,
-        subject: args.subject,
-        text: args.text,
-        sendAt: args.sendAt
+        to: args2.to,
+        subject: args2.subject,
+        text: args2.text,
+        sendAt: args2.sendAt
       });
       return `Email scheduled for ${r?.sendAt}. ID: ${r?.id}`;
     }
     case "create_folder": {
-      if (!args.name) throw new Error("name is required");
-      await apiRequest("POST", "/mail/folders", { name: args.name });
-      return `Folder "${args.name}" created successfully.`;
+      if (!args2.name) throw new Error("name is required");
+      await apiRequest("POST", "/mail/folders", { name: args2.name });
+      return `Folder "${args2.name}" created successfully.`;
     }
     case "manage_tags": {
-      const action = args.action;
+      const action = args2.action;
       if (action === "list") {
         const r = await apiRequest("GET", "/tags");
         if (!r?.tags?.length) return "No tags.";
         return r.tags.map((t) => `[${t.id.slice(0, 8)}] ${t.name} (${t.color})`).join("\n");
       }
       if (action === "create") {
-        if (!args.name) throw new Error("name is required");
-        const r = await apiRequest("POST", "/tags", { name: args.name, color: args.color });
-        return `Tag "${args.name}" created (${r?.color}). ID: ${r?.id}`;
+        if (!args2.name) throw new Error("name is required");
+        const r = await apiRequest("POST", "/tags", { name: args2.name, color: args2.color });
+        return `Tag "${args2.name}" created (${r?.color}). ID: ${r?.id}`;
       }
       if (action === "delete") {
-        if (!args.id) throw new Error("id is required");
-        await apiRequest("DELETE", `/tags/${args.id}`);
+        if (!args2.id) throw new Error("id is required");
+        await apiRequest("DELETE", `/tags/${args2.id}`);
         return "Tag deleted.";
       }
       if (action === "tag_message") {
-        if (!args.id || !args.uid) throw new Error("id and uid are required");
-        await apiRequest("POST", `/tags/${args.id}/messages`, { uid: args.uid, folder: args.folder });
-        return `Tagged message UID ${args.uid} with tag ${args.id}`;
+        if (!args2.id || !args2.uid) throw new Error("id and uid are required");
+        await apiRequest("POST", `/tags/${args2.id}/messages`, { uid: args2.uid, folder: args2.folder });
+        return `Tagged message UID ${args2.uid} with tag ${args2.id}`;
       }
       if (action === "untag_message") {
-        if (!args.id || !args.uid) throw new Error("id and uid are required");
-        const folder = args.folder || "INBOX";
-        await apiRequest("DELETE", `/tags/${args.id}/messages/${args.uid}?folder=${encodeURIComponent(folder)}`);
-        return `Removed tag from message UID ${args.uid} in ${folder}`;
+        if (!args2.id || !args2.uid) throw new Error("id and uid are required");
+        const folder = args2.folder || "INBOX";
+        await apiRequest("DELETE", `/tags/${args2.id}/messages/${args2.uid}?folder=${encodeURIComponent(folder)}`);
+        return `Removed tag from message UID ${args2.uid} in ${folder}`;
       }
       if (action === "get_messages") {
-        if (!args.id) throw new Error("id is required");
-        const r = await apiRequest("GET", `/tags/${args.id}/messages`);
+        if (!args2.id) throw new Error("id is required");
+        const r = await apiRequest("GET", `/tags/${args2.id}/messages`);
         if (!r?.messages?.length) return `No messages with this tag.`;
         return `Tag "${r.tag.name}" \u2014 ${r.messages.length} messages:
 ${r.messages.map((m) => `  UID ${m.uid} (${m.folder})`).join("\n")}`;
       }
       if (action === "get_message_tags") {
-        if (!args.uid) throw new Error("uid is required");
-        const r = await apiRequest("GET", `/messages/${args.uid}/tags`);
+        if (!args2.uid) throw new Error("uid is required");
+        const r = await apiRequest("GET", `/messages/${args2.uid}/tags`);
         if (!r?.tags?.length) return "No tags on this message.";
         return r.tags.map((t) => `[${t.id.slice(0, 8)}] ${t.name} (${t.color})`).join("\n");
       }
@@ -1453,9 +1454,9 @@ ${r.messages.map((m) => `  UID ${m.uid} (${m.folder})`).join("\n")}`;
     }
     case "create_account": {
       const result = await apiRequest("POST", "/accounts", {
-        name: args.name,
-        domain: args.domain,
-        role: args.role
+        name: args2.name,
+        domain: args2.domain,
+        role: args2.role
       }, useMaster);
       if (!result) throw new Error("No response from account creation");
       return [
@@ -1469,16 +1470,16 @@ ${r.messages.map((m) => `  UID ${m.uid} (${m.folder})`).join("\n")}`;
     }
     case "setup_email_relay": {
       const result = await apiRequest("POST", "/gateway/relay", {
-        provider: args.provider,
-        email: args.email,
-        password: args.password,
-        smtpHost: args.smtpHost,
-        smtpPort: args.smtpPort,
-        imapHost: args.imapHost,
-        imapPort: args.imapPort,
-        agentName: args.agentName,
-        agentRole: args.agentRole,
-        skipDefaultAgent: args.skipDefaultAgent
+        provider: args2.provider,
+        email: args2.email,
+        password: args2.password,
+        smtpHost: args2.smtpHost,
+        smtpPort: args2.smtpPort,
+        imapHost: args2.imapHost,
+        imapPort: args2.imapPort,
+        agentName: args2.agentName,
+        agentRole: args2.agentRole,
+        skipDefaultAgent: args2.skipDefaultAgent
       }, useMaster);
       if (!result) throw new Error("No response from relay setup");
       const lines = [
@@ -1498,11 +1499,11 @@ ${r.messages.map((m) => `  UID ${m.uid} (${m.folder})`).join("\n")}`;
     }
     case "setup_email_domain": {
       const result = await apiRequest("POST", "/gateway/domain", {
-        cloudflareToken: args.cloudflareToken,
-        cloudflareAccountId: args.cloudflareAccountId,
-        domain: args.domain,
-        purchase: args.purchase,
-        gmailRelay: args.gmailRelay
+        cloudflareToken: args2.cloudflareToken,
+        cloudflareAccountId: args2.cloudflareAccountId,
+        domain: args2.domain,
+        purchase: args2.purchase,
+        gmailRelay: args2.gmailRelay
       }, useMaster);
       if (!result) throw new Error("No response from domain setup");
       const lines = [
@@ -1542,8 +1543,8 @@ ${r.messages.map((m) => `  UID ${m.uid} (${m.folder})`).join("\n")}`;
     }
     case "setup_gmail_alias": {
       const result = await apiRequest("POST", "/gateway/domain/alias-setup", {
-        agentEmail: args.agentEmail,
-        agentDisplayName: args.agentDisplayName
+        agentEmail: args2.agentEmail,
+        agentDisplayName: args2.agentDisplayName
       }, useMaster);
       if (!result?.instructions) throw new Error("No response from alias setup");
       const lines = [
@@ -1580,8 +1581,8 @@ ${r.messages.map((m) => `  UID ${m.uid} (${m.folder})`).join("\n")}`;
     }
     case "purchase_domain": {
       const result = await apiRequest("POST", "/gateway/domain/purchase", {
-        keywords: args.keywords,
-        tld: args.tld
+        keywords: args2.keywords,
+        tld: args2.tld
       }, useMaster);
       if (!result?.domains?.length) return "No domains found.";
       const lines = result.domains.map(
@@ -1603,7 +1604,7 @@ ${lines.join("\n")}`;
       return lines.join("\n");
     }
     case "send_test_email": {
-      const result = await apiRequest("POST", "/gateway/test", { to: args.to }, useMaster);
+      const result = await apiRequest("POST", "/gateway/test", { to: args2.to }, useMaster);
       return `Test email sent! Message ID: ${result?.messageId ?? "unknown"}`;
     }
     case "list_agents": {
@@ -1615,7 +1616,7 @@ ${lines.join("\n")}`;
 ${lines.join("\n")}`;
     }
     case "message_agent": {
-      const agentName = String(args.agent ?? "").toLowerCase().trim();
+      const agentName = String(args2.agent ?? "").toLowerCase().trim();
       if (!agentName) throw new Error("agent name is required");
       try {
         await apiRequest("GET", `/accounts/directory/${encodeURIComponent(agentName)}`);
@@ -1623,9 +1624,9 @@ ${lines.join("\n")}`;
         throw new Error(`Agent "${agentName}" not found. Use list_agents to see available agents.`);
       }
       const to = `${agentName}@localhost`;
-      const priority = String(args.priority ?? "normal");
-      const subject = priority === "urgent" ? `[URGENT] ${args.subject}` : priority === "high" ? `[HIGH] ${args.subject}` : String(args.subject);
-      const result = await apiRequest("POST", "/mail/send", { to, subject, text: args.text });
+      const priority = String(args2.priority ?? "normal");
+      const subject = priority === "urgent" ? `[URGENT] ${args2.subject}` : priority === "high" ? `[HIGH] ${args2.subject}` : String(args2.subject);
+      const result = await apiRequest("POST", "/mail/send", { to, subject, text: args2.text });
       return `Message sent to ${to}. Message ID: ${result?.messageId ?? "unknown"}`;
     }
     case "check_messages": {
@@ -1650,13 +1651,13 @@ ${lines.join("\n")}`;
 ${details.join("\n")}${more}`;
     }
     case "delete_agent": {
-      const agentName = String(args.name ?? "").trim();
+      const agentName = String(args2.name ?? "").trim();
       if (!agentName) throw new Error("name is required");
       const agents = await apiRequest("GET", "/accounts", void 0, true);
       const fullAgent = agents?.agents?.find((a) => a.name === agentName);
       if (!fullAgent) throw new Error(`Agent "${agentName}" not found`);
       const qs = new URLSearchParams({ archive: "true", deletedBy: "mcp-tool" });
-      if (args.reason) qs.set("reason", String(args.reason));
+      if (args2.reason) qs.set("reason", String(args2.reason));
       const report = await apiRequest("DELETE", `/accounts/${fullAgent.id}?${qs.toString()}`, void 0, true);
       const lines = [
         `Agent "${agentName}" deleted successfully.`,
@@ -1670,8 +1671,8 @@ ${details.join("\n")}${more}`;
       return lines.join("\n");
     }
     case "deletion_reports": {
-      if (args.id) {
-        const report = await apiRequest("GET", `/accounts/deletions/${encodeURIComponent(String(args.id))}`, void 0, true);
+      if (args2.id) {
+        const report = await apiRequest("GET", `/accounts/deletions/${encodeURIComponent(String(args2.id))}`, void 0, true);
         if (!report) throw new Error("Deletion report not found");
         const lines2 = [
           `Deletion Report: ${report.id}`,
@@ -1699,52 +1700,52 @@ ${details.join("\n")}${more}`;
 ${lines.join("\n")}`;
     }
     case "manage_signatures": {
-      if (args.action === "list") {
+      if (args2.action === "list") {
         const r = await apiRequest("GET", "/signatures");
         if (!r?.signatures?.length) return "No signatures.";
         return r.signatures.map((s) => `[${s.id}] ${s.name}${s.isDefault ? " (default)" : ""}: ${s.text}`).join("\n");
       }
-      if (args.action === "create") {
-        if (!args.name || !args.text) throw new Error("name and text are required");
-        const r = await apiRequest("POST", "/signatures", { name: args.name, text: args.text, isDefault: args.isDefault });
-        return `Signature "${args.name}" created. ID: ${r?.id}`;
+      if (args2.action === "create") {
+        if (!args2.name || !args2.text) throw new Error("name and text are required");
+        const r = await apiRequest("POST", "/signatures", { name: args2.name, text: args2.text, isDefault: args2.isDefault });
+        return `Signature "${args2.name}" created. ID: ${r?.id}`;
       }
-      if (args.action === "delete") {
-        if (!args.id) throw new Error("id is required");
-        await apiRequest("DELETE", `/signatures/${args.id}`);
+      if (args2.action === "delete") {
+        if (!args2.id) throw new Error("id is required");
+        await apiRequest("DELETE", `/signatures/${args2.id}`);
         return "Signature deleted.";
       }
       throw new Error("Invalid action. Use: list, create, or delete");
     }
     case "manage_templates": {
-      if (args.action === "list") {
+      if (args2.action === "list") {
         const r = await apiRequest("GET", "/templates");
         if (!r?.templates?.length) return "No templates.";
         return r.templates.map((t) => `[${t.id}] ${t.name}: ${t.subject}`).join("\n");
       }
-      if (args.action === "create") {
-        if (!args.name || !args.subject || !args.text) throw new Error("name, subject, and text are required");
-        const r = await apiRequest("POST", "/templates", { name: args.name, subject: args.subject, text: args.text });
-        return `Template "${args.name}" created. ID: ${r?.id}`;
+      if (args2.action === "create") {
+        if (!args2.name || !args2.subject || !args2.text) throw new Error("name, subject, and text are required");
+        const r = await apiRequest("POST", "/templates", { name: args2.name, subject: args2.subject, text: args2.text });
+        return `Template "${args2.name}" created. ID: ${r?.id}`;
       }
-      if (args.action === "delete") {
-        if (!args.id) throw new Error("id is required");
-        await apiRequest("DELETE", `/templates/${args.id}`);
+      if (args2.action === "delete") {
+        if (!args2.id) throw new Error("id is required");
+        await apiRequest("DELETE", `/templates/${args2.id}`);
         return "Template deleted.";
       }
       throw new Error("Invalid action. Use: list, create, or delete");
     }
     case "batch_mark_unread": {
-      const uids = args.uids;
+      const uids = args2.uids;
       if (!Array.isArray(uids) || uids.length === 0) throw new Error("uids array required");
-      await apiRequest("POST", "/mail/batch/unseen", { uids, folder: args.folder });
+      await apiRequest("POST", "/mail/batch/unseen", { uids, folder: args2.folder });
       return `Marked ${uids.length} messages as unread.`;
     }
     case "batch_move": {
-      const uids = args.uids;
+      const uids = args2.uids;
       if (!Array.isArray(uids) || uids.length === 0) throw new Error("uids array required");
-      await apiRequest("POST", "/mail/batch/move", { uids, from: args.from || "INBOX", to: args.to });
-      return `Moved ${uids.length} messages to ${args.to}.`;
+      await apiRequest("POST", "/mail/batch/move", { uids, from: args2.from || "INBOX", to: args2.to });
+      return `Moved ${uids.length} messages to ${args2.to}.`;
     }
     case "whoami": {
       const result = await apiRequest("GET", "/accounts/me");
@@ -1759,8 +1760,8 @@ ${lines.join("\n")}`;
       ].filter(Boolean).join("\n");
     }
     case "update_metadata": {
-      if (!args.metadata || typeof args.metadata !== "object") throw new Error("metadata object is required");
-      const result = await apiRequest("PATCH", "/accounts/me", { metadata: args.metadata });
+      if (!args2.metadata || typeof args2.metadata !== "object") throw new Error("metadata object is required");
+      const result = await apiRequest("PATCH", "/accounts/me", { metadata: args2.metadata });
       return `Metadata updated successfully. Agent: ${result?.name ?? "unknown"}`;
     }
     case "check_health": {
@@ -1769,7 +1770,7 @@ ${lines.join("\n")}`;
       return `\u{1F380} AgenticMail server: ${result.status ?? "ok"}${result.stalwart ? `, Stalwart: ${result.stalwart}` : ""}`;
     }
     case "wait_for_email": {
-      const timeoutSec = Math.min(Math.max(Number(args.timeout) || 120, 5), 300);
+      const timeoutSec = Math.min(Math.max(Number(args2.timeout) || 120, 5), 300);
       const controller = new AbortController();
       const timer = setTimeout(() => controller.abort(), timeoutSec * 1e3);
       try {
@@ -1884,9 +1885,9 @@ ${lines.join("\n")}`;
       }
     }
     case "batch_read": {
-      const uids = args.uids;
+      const uids = args2.uids;
       if (!Array.isArray(uids) || uids.length === 0) throw new Error("uids array required");
-      const result = await apiRequest("POST", "/mail/batch/read", { uids, folder: args.folder });
+      const result = await apiRequest("POST", "/mail/batch/read", { uids, folder: args2.folder });
       if (!result?.messages?.length) return "No messages found for the given UIDs.";
       const lines = result.messages.map((m) => {
         const from = m.from?.map((a) => a.address).join(", ") ?? "unknown";
@@ -1899,10 +1900,10 @@ ${lines.join("\n\n---\n\n")}`;
     }
     case "inbox_digest": {
       const qs = new URLSearchParams();
-      if (args.limit) qs.set("limit", String(args.limit));
-      if (args.offset) qs.set("offset", String(args.offset));
-      if (args.folder) qs.set("folder", String(args.folder));
-      if (args.previewLength) qs.set("previewLength", String(args.previewLength));
+      if (args2.limit) qs.set("limit", String(args2.limit));
+      if (args2.offset) qs.set("offset", String(args2.offset));
+      if (args2.folder) qs.set("folder", String(args2.folder));
+      if (args2.previewLength) qs.set("previewLength", String(args2.previewLength));
       const query = qs.toString();
       const result = await apiRequest("GET", `/mail/digest${query ? "?" + query : ""}`);
       if (!result?.messages?.length) return "Inbox is empty.";
@@ -1916,16 +1917,16 @@ ${lines.join("\n\n---\n\n")}`;
 ${lines.join("\n")}`;
     }
     case "template_send": {
-      const result = await apiRequest("POST", `/templates/${args.id}/send`, {
-        to: args.to,
-        variables: args.variables,
-        cc: args.cc,
-        bcc: args.bcc
+      const result = await apiRequest("POST", `/templates/${args2.id}/send`, {
+        to: args2.to,
+        variables: args2.variables,
+        cc: args2.cc,
+        bcc: args2.bcc
       });
       return `Template email sent. Message ID: ${result?.messageId ?? "unknown"}`;
     }
     case "manage_rules": {
-      if (args.action === "list") {
+      if (args2.action === "list") {
         const r = await apiRequest("GET", "/rules");
         if (!r?.rules?.length) return "No email rules configured.";
         return r.rules.map(
@@ -1934,25 +1935,25 @@ ${lines.join("\n")}`;
   Actions: ${JSON.stringify(rule.actions)}`
         ).join("\n");
       }
-      if (args.action === "create") {
+      if (args2.action === "create") {
         const r = await apiRequest("POST", "/rules", {
-          name: args.name,
-          priority: args.priority,
-          conditions: args.conditions,
-          actions: args.actions
+          name: args2.name,
+          priority: args2.priority,
+          conditions: args2.conditions,
+          actions: args2.actions
         });
         return `Rule "${r?.name}" created. ID: ${r?.id}`;
       }
-      if (args.action === "delete") {
-        if (!args.id) throw new Error("id is required");
-        await apiRequest("DELETE", `/rules/${args.id}`);
+      if (args2.action === "delete") {
+        if (!args2.id) throw new Error("id is required");
+        await apiRequest("DELETE", `/rules/${args2.id}`);
         return "Rule deleted.";
       }
       throw new Error("Invalid action. Use: list, create, or delete");
     }
     case "cleanup_agents": {
-      if (args.action === "list_inactive") {
-        const qs = args.hours ? `?hours=${args.hours}` : "";
+      if (args2.action === "list_inactive") {
+        const qs = args2.hours ? `?hours=${args2.hours}` : "";
         const r = await apiRequest("GET", `/accounts/inactive${qs}`, void 0, true);
         if (!r?.agents?.length) return "No inactive agents found. All agents are either active or persistent.";
         return `${r.count} inactive agent(s):
@@ -1960,8 +1961,8 @@ ${r.agents.map(
           (a) => `  ${a.name} (${a.email}) \u2014 last active: ${a.last_activity_at || "never"}, persistent: ${a.persistent}`
         ).join("\n")}`;
       }
-      if (args.action === "cleanup") {
-        const r = await apiRequest("POST", "/accounts/cleanup", { hours: args.hours, dryRun: args.dryRun }, true);
+      if (args2.action === "cleanup") {
+        const r = await apiRequest("POST", "/accounts/cleanup", { hours: args2.hours, dryRun: args2.dryRun }, true);
         if (r?.dryRun) {
           if (!r.count) return "No inactive agents to clean up. All agents are either active or persistent.";
           return `Would delete ${r.count} agent(s): ${r.wouldDelete.map((a) => a.name).join(", ")}`;
@@ -1969,39 +1970,39 @@ ${r.agents.map(
         if (!r?.count) return "No inactive agents to clean up. All agents are either active or persistent.";
         return `Deleted ${r.count} agent(s): ${r.deleted.join(", ")}`;
       }
-      if (args.action === "set_persistent") {
-        if (!args.agentId) throw new Error("agentId is required");
-        await apiRequest("PATCH", `/accounts/${args.agentId}/persistent`, { persistent: args.persistent !== false }, true);
-        return `Agent ${args.agentId} persistent flag set to ${args.persistent !== false}`;
+      if (args2.action === "set_persistent") {
+        if (!args2.agentId) throw new Error("agentId is required");
+        await apiRequest("PATCH", `/accounts/${args2.agentId}/persistent`, { persistent: args2.persistent !== false }, true);
+        return `Agent ${args2.agentId} persistent flag set to ${args2.persistent !== false}`;
       }
       throw new Error("Invalid action. Use: list_inactive, cleanup, or set_persistent");
     }
     case "check_tasks": {
-      let endpoint = args.direction === "outgoing" ? "/tasks/assigned" : "/tasks/pending";
-      if (args.direction !== "outgoing" && args.assignee) {
-        endpoint += `?assignee=${encodeURIComponent(args.assignee)}`;
+      let endpoint = args2.direction === "outgoing" ? "/tasks/assigned" : "/tasks/pending";
+      if (args2.direction !== "outgoing" && args2.assignee) {
+        endpoint += `?assignee=${encodeURIComponent(args2.assignee)}`;
       }
       const r = await apiRequest("GET", endpoint);
-      if (!r?.tasks?.length) return args.direction === "outgoing" ? "No tasks assigned by you." : "No pending tasks.";
+      if (!r?.tasks?.length) return args2.direction === "outgoing" ? "No tasks assigned by you." : "No pending tasks.";
       return `${r.count} tasks:
 ${r.tasks.map(
         (t) => `  [${t.id.slice(0, 8)}] ${t.taskType} \u2014 status: ${t.status}, payload: ${JSON.stringify(t.payload).slice(0, 100)}`
       ).join("\n")}`;
     }
     case "claim_task": {
-      const r = await apiRequest("POST", `/tasks/${args.id}/claim`);
+      const r = await apiRequest("POST", `/tasks/${args2.id}/claim`);
       return `Task ${r?.id} claimed. Payload: ${JSON.stringify(r?.payload)}`;
     }
     case "submit_result": {
-      await apiRequest("POST", `/tasks/${args.id}/result`, { result: args.result });
-      return `Result submitted for task ${args.id}.`;
+      await apiRequest("POST", `/tasks/${args2.id}/result`, { result: args2.result });
+      return `Result submitted for task ${args2.id}.`;
     }
     case "call_agent": {
-      const timeoutSec = Math.min(Math.max(Number(args.timeout) || 180, 5), 300);
+      const timeoutSec = Math.min(Math.max(Number(args2.timeout) || 180, 5), 300);
       const created = await apiRequest("POST", "/tasks/assign", {
-        assignee: args.target,
+        assignee: args2.target,
         taskType: "rpc",
-        payload: { task: args.task, ...args.payload || {} }
+        payload: { task: args2.task, ...args2.payload || {} }
       });
       if (!created?.id) throw new Error("Failed to create task");
       const taskId = created.id;
@@ -2018,11 +2019,11 @@ ${r.tasks.map(
       return `RPC timed out. Task ID: ${taskId} \u2014 check later with check_tasks.`;
     }
     case "manage_spam": {
-      const action = args.action;
+      const action = args2.action;
       if (action === "list") {
         const qs = new URLSearchParams();
-        if (args.limit) qs.set("limit", String(args.limit));
-        if (args.offset) qs.set("offset", String(args.offset));
+        if (args2.limit) qs.set("limit", String(args2.limit));
+        if (args2.offset) qs.set("offset", String(args2.offset));
         const query = qs.toString();
         const result = await apiRequest("GET", `/mail/spam${query ? "?" + query : ""}`);
         if (!result?.messages?.length) return "Spam folder is empty.";
@@ -2031,21 +2032,21 @@ ${r.tasks.map(
 ${lines.join("\n")}`;
       }
       if (action === "report") {
-        const uid = Number(args.uid);
+        const uid = Number(args2.uid);
         if (!uid || uid < 1) throw new Error("uid is required");
-        await apiRequest("POST", `/mail/messages/${uid}/spam`, { folder: args.folder || "INBOX" });
+        await apiRequest("POST", `/mail/messages/${uid}/spam`, { folder: args2.folder || "INBOX" });
         return `Message UID ${uid} moved to Spam.`;
       }
       if (action === "not_spam") {
-        const uid = Number(args.uid);
+        const uid = Number(args2.uid);
         if (!uid || uid < 1) throw new Error("uid is required");
         await apiRequest("POST", `/mail/messages/${uid}/not-spam`);
         return `Message UID ${uid} moved from Spam to INBOX.`;
       }
       if (action === "score") {
-        const uid = Number(args.uid);
+        const uid = Number(args2.uid);
         if (!uid || uid < 1) throw new Error("uid is required");
-        const folder = args.folder || "INBOX";
+        const folder = args2.folder || "INBOX";
         const result = await apiRequest("GET", `/mail/messages/${uid}/spam-score?folder=${encodeURIComponent(folder)}`);
         const lines = [
           `Spam Score: ${result.score}/100 (${result.isSpam ? "SPAM" : result.isWarning ? "WARNING" : "CLEAN"})`,
@@ -2062,7 +2063,7 @@ ${lines.join("\n")}`;
       throw new Error("Invalid action. Use: list, report, not_spam, or score");
     }
     case "manage_pending_emails": {
-      const action = String(args.action);
+      const action = String(args2.action);
       if (action === "list") {
         const result = await apiRequest("GET", "/mail/pending");
         if (result?.pending) {
@@ -2076,10 +2077,10 @@ ${lines.join("\n")}`;
 ${lines.join("\n")}`);
       }
       if (action === "get") {
-        if (!args.id) throw new Error("id is required");
-        const result = await apiRequest("GET", `/mail/pending/${encodeURIComponent(String(args.id))}`);
+        if (!args2.id) throw new Error("id is required");
+        const result = await apiRequest("GET", `/mail/pending/${encodeURIComponent(String(args2.id))}`);
         if (!result) throw new Error("Pending email not found");
-        if (result.status !== "pending") cancelFollowUp(String(args.id));
+        if (result.status !== "pending") cancelFollowUp(String(args2.id));
         return withReminders(`Pending Email: ${result.id}
 To: ${result.mailOptions?.to}
 Subject: ${result.mailOptions?.subject}
@@ -2096,106 +2097,106 @@ ${result.summary}`);
     // --- SMS / Google Voice Tools ---
     case "sms_setup": {
       const result = await apiRequest("POST", "/sms/setup", {
-        phoneNumber: args.phoneNumber,
-        forwardingEmail: args.forwardingEmail,
+        phoneNumber: args2.phoneNumber,
+        forwardingEmail: args2.forwardingEmail,
         provider: "google_voice"
       });
       return JSON.stringify(result, null, 2);
     }
     case "sms_send": {
       const result = await apiRequest("POST", "/sms/send", {
-        to: args.to,
-        body: args.body
+        to: args2.to,
+        body: args2.body
       });
       return JSON.stringify(result, null, 2);
     }
     case "sms_messages": {
       const query = new URLSearchParams();
-      if (args.direction) query.set("direction", String(args.direction));
-      if (args.limit) query.set("limit", String(args.limit));
-      if (args.offset) query.set("offset", String(args.offset));
+      if (args2.direction) query.set("direction", String(args2.direction));
+      if (args2.limit) query.set("limit", String(args2.limit));
+      if (args2.offset) query.set("offset", String(args2.offset));
       const result = await apiRequest("GET", `/sms/messages?${query.toString()}`);
       return JSON.stringify(result, null, 2);
     }
     case "sms_check_code": {
-      const query = args.minutes ? `?minutes=${args.minutes}` : "";
+      const query = args2.minutes ? `?minutes=${args2.minutes}` : "";
       const result = await apiRequest("GET", `/sms/verification-code${query}`);
       return JSON.stringify(result, null, 2);
     }
     case "sms_parse_email": {
       const result = await apiRequest("POST", "/sms/parse-email", {
-        emailBody: args.emailBody,
-        emailFrom: args.emailFrom
+        emailBody: args2.emailBody,
+        emailFrom: args2.emailFrom
       });
       return JSON.stringify(result, null, 2);
     }
     case "storage": {
-      const act = args.action;
-      const tbl = args.table ? encodeURIComponent(args.table) : "";
+      const act = args2.action;
+      const tbl = args2.table ? encodeURIComponent(args2.table) : "";
       let result;
       switch (act) {
         // DDL
         case "create_table":
-          result = await apiRequest("POST", "/storage/tables", { name: args.table, columns: args.columns, indexes: args.indexes, shared: args.shared, description: args.description, timestamps: args.timestamps });
+          result = await apiRequest("POST", "/storage/tables", { name: args2.table, columns: args2.columns, indexes: args2.indexes, shared: args2.shared, description: args2.description, timestamps: args2.timestamps });
           break;
         case "list_tables":
-          result = await apiRequest("GET", `/storage/tables?includeShared=${args.includeShared !== false}&includeArchived=${args.includeArchived === true}`);
+          result = await apiRequest("GET", `/storage/tables?includeShared=${args2.includeShared !== false}&includeArchived=${args2.includeArchived === true}`);
           break;
         case "describe_table":
           result = await apiRequest("GET", `/storage/tables/${tbl}/describe`);
           break;
         case "add_column":
-          result = await apiRequest("POST", `/storage/tables/${tbl}/columns`, { column: args.column });
+          result = await apiRequest("POST", `/storage/tables/${tbl}/columns`, { column: args2.column });
           break;
         case "drop_column":
-          result = await apiRequest("DELETE", `/storage/tables/${tbl}/columns/${encodeURIComponent(args.columnName)}`);
+          result = await apiRequest("DELETE", `/storage/tables/${tbl}/columns/${encodeURIComponent(args2.columnName)}`);
           break;
         case "rename_table":
-          result = await apiRequest("POST", `/storage/tables/${tbl}/rename`, { newName: args.newName });
+          result = await apiRequest("POST", `/storage/tables/${tbl}/rename`, { newName: args2.newName });
           break;
         case "rename_column":
-          result = await apiRequest("POST", `/storage/tables/${tbl}/rename-column`, { oldName: args.oldName, newName: args.newName });
+          result = await apiRequest("POST", `/storage/tables/${tbl}/rename-column`, { oldName: args2.oldName, newName: args2.newName });
           break;
         case "drop_table":
           result = await apiRequest("DELETE", `/storage/tables/${tbl}`);
           break;
         case "clone_table":
-          result = await apiRequest("POST", `/storage/tables/${tbl}/clone`, { newName: args.newName, includeData: args.includeData });
+          result = await apiRequest("POST", `/storage/tables/${tbl}/clone`, { newName: args2.newName, includeData: args2.includeData });
           break;
         case "truncate":
           result = await apiRequest("POST", `/storage/tables/${tbl}/truncate`);
           break;
         // Indexes
         case "create_index":
-          result = await apiRequest("POST", `/storage/tables/${tbl}/indexes`, { columns: args.indexColumns || args.columns, unique: args.indexUnique, name: args.indexName, where: args.indexWhere });
+          result = await apiRequest("POST", `/storage/tables/${tbl}/indexes`, { columns: args2.indexColumns || args2.columns, unique: args2.indexUnique, name: args2.indexName, where: args2.indexWhere });
           break;
         case "list_indexes":
           result = await apiRequest("GET", `/storage/tables/${tbl}/indexes`);
           break;
         case "drop_index":
-          result = await apiRequest("DELETE", `/storage/tables/${tbl}/indexes/${encodeURIComponent(args.indexName)}`);
+          result = await apiRequest("DELETE", `/storage/tables/${tbl}/indexes/${encodeURIComponent(args2.indexName)}`);
           break;
         case "reindex":
           result = await apiRequest("POST", `/storage/tables/${tbl}/reindex`);
           break;
         // DML
         case "insert":
-          result = await apiRequest("POST", "/storage/insert", { table: args.table, rows: args.rows });
+          result = await apiRequest("POST", "/storage/insert", { table: args2.table, rows: args2.rows });
           break;
         case "upsert":
-          result = await apiRequest("POST", "/storage/upsert", { table: args.table, rows: args.rows, conflictColumn: args.conflictColumn });
+          result = await apiRequest("POST", "/storage/upsert", { table: args2.table, rows: args2.rows, conflictColumn: args2.conflictColumn });
           break;
         case "query":
-          result = await apiRequest("POST", "/storage/query", { table: args.table, where: args.where, orderBy: args.orderBy, limit: args.limit, offset: args.offset, columns: args.selectColumns, distinct: args.distinct, groupBy: args.groupBy, having: args.having });
+          result = await apiRequest("POST", "/storage/query", { table: args2.table, where: args2.where, orderBy: args2.orderBy, limit: args2.limit, offset: args2.offset, columns: args2.selectColumns, distinct: args2.distinct, groupBy: args2.groupBy, having: args2.having });
           break;
         case "aggregate":
-          result = await apiRequest("POST", "/storage/aggregate", { table: args.table, where: args.where, operations: args.operations, groupBy: args.groupBy });
+          result = await apiRequest("POST", "/storage/aggregate", { table: args2.table, where: args2.where, operations: args2.operations, groupBy: args2.groupBy });
           break;
         case "update":
-          result = await apiRequest("POST", "/storage/update", { table: args.table, where: args.where, set: args.set });
+          result = await apiRequest("POST", "/storage/update", { table: args2.table, where: args2.where, set: args2.set });
           break;
         case "delete_rows":
-          result = await apiRequest("POST", "/storage/delete-rows", { table: args.table, where: args.where });
+          result = await apiRequest("POST", "/storage/delete-rows", { table: args2.table, where: args2.where });
           break;
         // Archive
         case "archive_table":
@@ -2206,17 +2207,17 @@ ${result.summary}`);
           break;
         // Import/Export
         case "export":
-          result = await apiRequest("POST", `/storage/tables/${tbl}/export`, { format: args.format, where: args.where, limit: args.limit });
+          result = await apiRequest("POST", `/storage/tables/${tbl}/export`, { format: args2.format, where: args2.where, limit: args2.limit });
           break;
         case "import":
-          result = await apiRequest("POST", `/storage/tables/${tbl}/import`, { rows: args.rows, onConflict: args.onConflict, conflictColumn: args.conflictColumn });
+          result = await apiRequest("POST", `/storage/tables/${tbl}/import`, { rows: args2.rows, onConflict: args2.onConflict, conflictColumn: args2.conflictColumn });
           break;
         // Raw SQL
         case "sql":
-          result = await apiRequest("POST", "/storage/sql", { sql: args.sql, params: args.params });
+          result = await apiRequest("POST", "/storage/sql", { sql: args2.sql, params: args2.params });
           break;
         case "explain":
-          result = await apiRequest("POST", "/storage/explain", { sql: args.sql, params: args.params });
+          result = await apiRequest("POST", "/storage/explain", { sql: args2.sql, params: args2.params });
           break;
         // Maintenance
         case "stats":
@@ -2255,8 +2256,8 @@ ${result.summary}`);
     }
     case "sms_record": {
       const result = await apiRequest("POST", "/sms/record", {
-        from: args.from,
-        body: args.body
+        from: args2.from,
+        body: args2.body
       });
       return JSON.stringify(result, null, 2);
     }
@@ -2322,64 +2323,158 @@ ${lines.join("\n")}`;
 
 // src/index.ts
 import { setTelemetryVersion } from "@agenticmail/core";
-setTelemetryVersion("0.5.39");
-var server = new McpServer({
-  name: "\u{1F380} AgenticMail",
-  version: "0.2.26",
-  description: "\u{1F380} AgenticMail \u2014 Email infrastructure for AI agents. By Ope Olatunji (https://github.com/agenticmail/agenticmail)"
-});
-for (const tool of toolDefinitions) {
-  server.tool(
-    tool.name,
-    tool.description,
-    tool.inputSchema,
-    async ({ arguments: args }) => {
-      try {
-        const result = await handleToolCall(tool.name, args);
-        return { content: [{ type: "text", text: result }] };
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        return {
-          content: [{ type: "text", text: `Error: ${message}` }],
-          isError: true
-        };
+import { createServer } from "http";
+import { randomUUID } from "crypto";
+setTelemetryVersion("0.5.50");
+function createMcpServer() {
+  const server = new McpServer({
+    name: "\u{1F380} AgenticMail",
+    version: "0.2.27",
+    description: "\u{1F380} AgenticMail \u2014 Email infrastructure for AI agents. By Ope Olatunji (https://github.com/agenticmail/agenticmail)"
+  });
+  for (const tool of toolDefinitions) {
+    server.tool(
+      tool.name,
+      tool.description,
+      tool.inputSchema,
+      async ({ arguments: args2 }) => {
+        try {
+          const result = await handleToolCall(tool.name, args2);
+          return { content: [{ type: "text", text: result }] };
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          return {
+            content: [{ type: "text", text: `Error: ${message}` }],
+            isError: true
+          };
+        }
       }
-    }
-  );
+    );
+  }
+  for (const resource of resourceDefinitions) {
+    server.resource(
+      resource.name,
+      resource.uri,
+      { description: resource.description, mimeType: resource.mimeType },
+      async () => {
+        try {
+          const content = await handleResourceRead(resource.uri);
+          return {
+            contents: [{ uri: resource.uri, text: content, mimeType: resource.mimeType }]
+          };
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          return {
+            contents: [{ uri: resource.uri, text: `Error: ${message}`, mimeType: "text/plain" }]
+          };
+        }
+      }
+    );
+  }
+  return server;
 }
-for (const resource of resourceDefinitions) {
-  server.resource(
-    resource.name,
-    resource.uri,
-    { description: resource.description, mimeType: resource.mimeType },
-    async () => {
+var args = process.argv.slice(2);
+var httpFlag = args.includes("--http");
+var portArg = args.find((a) => a.startsWith("--port="));
+var httpPort = portArg ? parseInt(portArg.split("=")[1], 10) : parseInt(process.env.MCP_PORT || "", 10) || 8014;
+if (httpFlag || process.env.MCP_HTTP === "1") {
+  const server = createMcpServer();
+  const transports = /* @__PURE__ */ new Map();
+  const httpServer = createServer(async (req, res) => {
+    const url = new URL(req.url ?? "/", `http://localhost:${httpPort}`);
+    const path = url.pathname;
+    if (path === "/health" && req.method === "GET") {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ status: "ok", transport: "streamable-http", sessions: transports.size }));
+      return;
+    }
+    if (path !== "/mcp") {
+      res.writeHead(404, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Not found. MCP endpoint is POST /mcp" }));
+      return;
+    }
+    if (req.method === "DELETE") {
+      const sessionId = req.headers["mcp-session-id"];
+      if (sessionId && transports.has(sessionId)) {
+        const transport = transports.get(sessionId);
+        await transport.handleRequest(req, res);
+        transports.delete(sessionId);
+      } else {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Invalid or missing session ID" }));
+      }
+      return;
+    }
+    if (req.method === "GET") {
+      const sessionId = req.headers["mcp-session-id"];
+      if (sessionId && transports.has(sessionId)) {
+        const transport = transports.get(sessionId);
+        await transport.handleRequest(req, res);
+      } else {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Invalid or missing session ID for SSE stream. Send a POST /mcp with initialize first." }));
+      }
+      return;
+    }
+    if (req.method === "POST") {
+      const sessionId = req.headers["mcp-session-id"];
+      if (sessionId && transports.has(sessionId)) {
+        const transport2 = transports.get(sessionId);
+        await transport2.handleRequest(req, res);
+        return;
+      }
+      const transport = new StreamableHTTPServerTransport({
+        sessionIdGenerator: () => randomUUID(),
+        onsessioninitialized: (sid) => {
+          transports.set(sid, transport);
+        }
+      });
+      transport.onclose = () => {
+        const sid = transport.sessionId;
+        if (sid) transports.delete(sid);
+      };
+      const sessionServer = createMcpServer();
+      await sessionServer.connect(transport);
+      await transport.handleRequest(req, res);
+      return;
+    }
+    res.writeHead(405, { "Allow": "GET, POST, DELETE", "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "Method not allowed. Use POST /mcp for JSON-RPC, GET /mcp for SSE stream." }));
+  });
+  httpServer.listen(httpPort, () => {
+    console.log(`\u{1F380} AgenticMail MCP Server (Streamable HTTP)`);
+    console.log(`   Endpoint: http://localhost:${httpPort}/mcp`);
+    console.log(`   Health:   http://localhost:${httpPort}/health`);
+    console.log(`   Transport: Streamable HTTP (SSE + JSON responses)`);
+  });
+  async function shutdown() {
+    for (const transport of transports.values()) {
       try {
-        const content = await handleResourceRead(resource.uri);
-        return {
-          contents: [{ uri: resource.uri, text: content, mimeType: resource.mimeType }]
-        };
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        return {
-          contents: [{ uri: resource.uri, text: `Error: ${message}`, mimeType: "text/plain" }]
-        };
+        await transport.close();
+      } catch {
       }
     }
-  );
-}
-var transport = new StdioServerTransport();
-try {
-  await server.connect(transport);
-} catch (err) {
-  console.error("[agenticmail-mcp] Failed to start:", err);
-  process.exit(1);
-}
-async function shutdown() {
+    httpServer.close();
+    process.exit(0);
+  }
+  process.on("SIGTERM", () => shutdown());
+  process.on("SIGINT", () => shutdown());
+} else {
+  const server = createMcpServer();
+  const transport = new StdioServerTransport();
   try {
-    await server.close();
-  } catch {
+    await server.connect(transport);
+  } catch (err) {
+    console.error("[agenticmail-mcp] Failed to start:", err);
+    process.exit(1);
+  }
+  async function shutdown() {
+    try {
+      await server.close();
+    } catch {
+    }
+    process.exit(0);
   }
-  process.exit(0);
+  process.on("SIGTERM", () => shutdown());
+  process.on("SIGINT", () => shutdown());
 }
-process.on("SIGTERM", () => shutdown());
-process.on("SIGINT", () => shutdown());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agenticmail/mcp",
-  "version": "0.5.49",
+  "version": "0.5.51",
   "description": "MCP server for AgenticMail — give any AI client real email and SMS capabilities",
   "type": "module",
   "main": "dist/index.js",