clay-server 2.30.0-beta.2 → 2.31.0-beta.1

package/lib/email-mcp-server.js

@@ -0,0 +1,646 @@
+// Email MCP Server for Clay (in-process SDK version)
+// Provides email tools (send, read, search, reply, list labels, mark read)
+// to Claude via createSdkMcpServer.
+//
+// Usage:
+//   var emailMcp = require("./email-mcp-server");
+//   var mcpConfig = emailMcp.create(getEmailAccount, getCheckedAccounts, smtpConfig);
+//   // Pass mcpConfig to sdk-bridge opts.mcpServers
+
+var z;
+try { z = require("zod"); } catch (e) { z = null; }
+
+function buildShape(props, required) {
+  if (!z) return {};
+  var shape = {};
+  var keys = Object.keys(props);
+  for (var i = 0; i < keys.length; i++) {
+    var k = keys[i];
+    var p = props[k];
+    var field;
+    if (p.type === "number") field = z.number();
+    else if (p.type === "boolean") field = z.boolean();
+    else if (p.enum) field = z.enum(p.enum);
+    else if (p.type === "array") field = z.array(z.string());
+    else field = z.string();
+    if (p.description) field = field.describe(p.description);
+    if (!required || required.indexOf(k) === -1) field = field.optional();
+    shape[k] = field;
+  }
+  return shape;
+}
+
+// deps:
+//   getAccountForTool(email) -> decrypted account object or null
+//   getCheckedAccounts() -> array of decrypted accounts (context source checked)
+//   getServerSmtp() -> { sendMail(to, subject, html), from } or null
+//   appendAuditLog(entry) -> void
+function create(deps) {
+  var sdk;
+  try { sdk = require("@anthropic-ai/claude-agent-sdk"); } catch (e) {
+    console.error("[email-mcp] Failed to load SDK:", e.message);
+    return null;
+  }
+
+  var createSdkMcpServer = sdk.createSdkMcpServer;
+  var tool = sdk.tool;
+  if (!createSdkMcpServer || !tool) {
+    console.error("[email-mcp] SDK missing createSdkMcpServer or tool helper");
+    return null;
+  }
+
+  var nodemailer = require("nodemailer");
+  var tools = [];
+
+  // --- Helper: get SMTP transport for a personal account ---
+  function getPersonalTransport(account) {
+    return nodemailer.createTransport({
+      host: account.smtp.host,
+      port: account.smtp.port || 587,
+      secure: false,
+      auth: { user: account.email, pass: account.appPassword },
+      connectionTimeout: 10000,
+      greetingTimeout: 10000,
+    });
+  }
+
+  // --- Helper: get IMAP client for a personal account ---
+  function getImapClient(account) {
+    var ImapFlow;
+    try { ImapFlow = require("imapflow").ImapFlow; } catch (e) {
+      return null;
+    }
+    return new ImapFlow({
+      host: account.imap.host,
+      port: account.imap.port || 993,
+      secure: account.imap.tls !== false,
+      auth: { user: account.email, pass: account.appPassword },
+      logger: false,
+    });
+  }
+
+  // --- clay_send_email ---
+  tools.push(tool(
+    "clay_send_email",
+    "Send an email. Use via='server' for auditable server SMTP, via='personal' for user's own account, or omit for auto-detect (personal if available, otherwise server).",
+    buildShape({
+      to: { type: "string", description: "Comma-separated recipient email addresses" },
+      subject: { type: "string", description: "Email subject line" },
+      body: { type: "string", description: "Email body (plain text)" },
+      account: { type: "string", description: "Sender email address (for personal mode). If omitted, uses first checked account." },
+      via: { type: "string", description: "Send mode: 'server' (admin SMTP, audited) or 'personal' (user account). Omit for auto-detect." },
+      cc: { type: "string", description: "Comma-separated CC addresses" },
+      bcc: { type: "string", description: "Comma-separated BCC addresses" },
+    }, ["to", "subject", "body"]),
+    function (args) {
+      var via = args.via || "auto";
+      var recipients = args.to.split(",").map(function (s) { return s.trim(); }).filter(Boolean);
+
+      if (via === "server" || (via === "auto" && !deps.getCheckedAccounts().length)) {
+        // Server SMTP mode
+        var serverSmtp = deps.getServerSmtp();
+        if (!serverSmtp) {
+          return Promise.resolve({ content: [{ type: "text", text: "Error: Server SMTP is not configured. Ask the admin to set it up, or connect a personal email account." }] });
+        }
+        return serverSmtp.sendMail(recipients.join(", "), args.subject, args.body).then(function (info) {
+          // Audit log
+          deps.appendAuditLog({
+            ts: Date.now(),
+            to: recipients,
+            subject: args.subject,
+            status: "sent",
+            messageId: info.messageId || null,
+          });
+          return { content: [{ type: "text", text: "Email sent via server SMTP to " + recipients.join(", ") + ". Subject: " + args.subject }] };
+        }).catch(function (err) {
+          return { content: [{ type: "text", text: "Error sending via server SMTP: " + (err.message || "Unknown error") }] };
+        });
+      }
+
+      // Personal account mode
+      var account;
+      if (args.account) {
+        account = deps.getAccountForTool(args.account);
+      } else {
+        var checked = deps.getCheckedAccounts();
+        account = checked.length > 0 ? checked[0] : null;
+      }
+
+      if (!account) {
+        return Promise.resolve({ content: [{ type: "text", text: "Error: No personal email account available. The user needs to add and check an email account in Context Sources." }] });
+      }
+
+      var transport = getPersonalTransport(account);
+      var mailOpts = {
+        from: account.email,
+        to: recipients.join(", "),
+        subject: args.subject,
+        text: args.body,
+      };
+      if (args.cc) mailOpts.cc = args.cc;
+      if (args.bcc) mailOpts.bcc = args.bcc;
+
+      return transport.sendMail(mailOpts).then(function (info) {
+        try { transport.close(); } catch (e) {}
+        return { content: [{ type: "text", text: "Email sent from " + account.email + " to " + recipients.join(", ") + ". Subject: " + args.subject }] };
+      }).catch(function (err) {
+        try { transport.close(); } catch (e) {}
+        return { content: [{ type: "text", text: "Error sending from " + account.email + ": " + (err.message || "Unknown error") }] };
+      });
+    }
+  ));
+
+  // --- clay_read_email ---
+  tools.push(tool(
+    "clay_read_email",
+    "Read recent emails from inbox or a specified folder. Returns message list with snippets. Use clay_read_email_body to get full content.",
+    buildShape({
+      account: { type: "string", description: "Email address of the account to read from. If omitted, uses first checked account." },
+      folder: { type: "string", description: "Folder/mailbox name (default: INBOX)" },
+      limit: { type: "number", description: "Number of messages to fetch (default 10, max 50)" },
+      unread_only: { type: "boolean", description: "Only fetch unread messages (default false)" },
+    }, []),
+    function (args) {
+      var account;
+      if (args.account) {
+        account = deps.getAccountForTool(args.account);
+      } else {
+        var checked = deps.getCheckedAccounts();
+        account = checked.length > 0 ? checked[0] : null;
+      }
+      if (!account) {
+        return Promise.resolve({ content: [{ type: "text", text: "Error: No email account available. The user needs to add and check an email account." }] });
+      }
+
+      var client = getImapClient(account);
+      if (!client) {
+        return Promise.resolve({ content: [{ type: "text", text: "Error: IMAP module (imapflow) not available." }] });
+      }
+
+      var folder = args.folder || "INBOX";
+      var limit = Math.min(Math.max(args.limit || 10, 1), 50);
+      var unreadOnly = !!args.unread_only;
+
+      return client.connect().then(function () {
+        return client.getMailboxLock(folder);
+      }).then(function (lock) {
+        var searchCriteria = unreadOnly ? { seen: false } : { all: true };
+        return client.search(searchCriteria, { uid: true }).then(function (uids) {
+          if (!uids || uids.length === 0) {
+            lock.release();
+            return client.logout().then(function () {
+              return { content: [{ type: "text", text: JSON.stringify({ messages: [], total: 0, unread: 0 }, null, 2) }] };
+            });
+          }
+
+          // Get the most recent N UIDs
+          var recentUids = uids.slice(-limit).reverse();
+
+          // client.fetch is async*, returns AsyncGenerator directly
+          var fetchIter = client.fetch(recentUids, {
+            uid: true,
+            envelope: true,
+            flags: true,
+            bodyStructure: true,
+            source: { start: 0, maxLength: 500 },
+          }, { uid: true });
+          var messages = [];
+
+          function collectMessages() {
+            return fetchIter.next().then(function (result) {
+              if (result.done) return;
+              var msg = result.value;
+              var env = msg.envelope || {};
+              var fromAddr = env.from && env.from[0] ? (env.from[0].address || "") : "";
+              var toAddrs = (env.to || []).map(function (a) { return a.address || ""; });
+              var snippet = "";
+              if (msg.source) {
+                snippet = msg.source.toString("utf8").replace(/\r?\n/g, " ").substring(0, 200);
+              }
+              messages.push({
+                uid: msg.uid,
+                from: fromAddr,
+                to: toAddrs,
+                subject: env.subject || "(no subject)",
+                date: env.date ? env.date.toISOString() : null,
+                snippet: snippet,
+                unread: !msg.flags || !msg.flags.has("\\Seen"),
+              });
+              return collectMessages();
+            });
+          }
+
+          return collectMessages().then(function () {
+            lock.release();
+            return client.logout().then(function () {
+              return {
+                content: [{ type: "text", text: JSON.stringify({
+                  messages: messages,
+                  total: uids.length,
+                  account: account.email,
+                  folder: folder,
+                }, null, 2) }],
+              };
+            });
+          });
+        });
+      }).catch(function (err) {
+        try { client.close(); } catch (e) {}
+        return { content: [{ type: "text", text: "Error reading email from " + account.email + ": " + (err.message || "Unknown error") }] };
+      });
+    }
+  ));
+
+  // --- clay_read_email_body ---
+  tools.push(tool(
+    "clay_read_email_body",
+    "Read the full body of a specific email by UID. Returns plain text content (HTML stripped). Truncated at 10,000 characters.",
+    buildShape({
+      account: { type: "string", description: "Email address of the account. If omitted, uses first checked account." },
+      uid: { type: "number", description: "Message UID (from clay_read_email results)" },
+      folder: { type: "string", description: "Folder/mailbox name (default: INBOX)" },
+    }, ["uid"]),
+    function (args) {
+      var account;
+      if (args.account) {
+        account = deps.getAccountForTool(args.account);
+      } else {
+        var checked = deps.getCheckedAccounts();
+        account = checked.length > 0 ? checked[0] : null;
+      }
+      if (!account) {
+        return Promise.resolve({ content: [{ type: "text", text: "Error: No email account available." }] });
+      }
+
+      var client = getImapClient(account);
+      if (!client) {
+        return Promise.resolve({ content: [{ type: "text", text: "Error: IMAP module not available." }] });
+      }
+
+      var folder = args.folder || "INBOX";
+      var MAX_BODY = 10000;
+
+      return client.connect().then(function () {
+        return client.getMailboxLock(folder);
+      }).then(function (lock) {
+        return client.fetchOne(args.uid, {
+          uid: true,
+          source: true,
+        }, { uid: true }).then(function (msg) {
+          lock.release();
+          return client.logout().then(function () {
+            if (!msg || !msg.source) {
+              return { content: [{ type: "text", text: "Message not found or empty." }] };
+            }
+            var raw = msg.source.toString("utf8");
+            // Simple extraction: try to get text content after headers
+            var bodyStart = raw.indexOf("\r\n\r\n");
+            if (bodyStart === -1) bodyStart = raw.indexOf("\n\n");
+            var body = bodyStart !== -1 ? raw.substring(bodyStart + (raw[bodyStart + 2] === "\n" ? 4 : 2)) : raw;
+            // Strip HTML tags for a rough plain text extraction
+            body = body.replace(/<[^>]+>/g, "").replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">");
+            // Clean up whitespace
+            body = body.replace(/\r\n/g, "\n").replace(/\n{3,}/g, "\n\n").trim();
+            if (body.length > MAX_BODY) {
+              body = body.substring(0, MAX_BODY) + "\n\n[Truncated at " + MAX_BODY + " characters]";
+            }
+            return { content: [{ type: "text", text: body }] };
+          });
+        });
+      }).catch(function (err) {
+        try { client.close(); } catch (e) {}
+        return { content: [{ type: "text", text: "Error reading email body: " + (err.message || "Unknown error") }] };
+      });
+    }
+  ));
+
+  // --- clay_search_email ---
+  tools.push(tool(
+    "clay_search_email",
+    "Search emails using IMAP search criteria. Supports basic criteria like from, subject, since, before, and text content.",
+    buildShape({
+      account: { type: "string", description: "Email address of the account. If omitted, uses first checked account." },
+      from: { type: "string", description: "Filter by sender address (partial match)" },
+      subject: { type: "string", description: "Filter by subject text (partial match)" },
+      text: { type: "string", description: "Search in entire message body and headers" },
+      since: { type: "string", description: "Messages after this date (ISO 8601 format, e.g. 2026-04-15)" },
+      before: { type: "string", description: "Messages before this date (ISO 8601 format)" },
+      folder: { type: "string", description: "Folder/mailbox name (default: INBOX)" },
+      limit: { type: "number", description: "Max results (default 20, max 50)" },
+    }, []),
+    function (args) {
+      var account;
+      if (args.account) {
+        account = deps.getAccountForTool(args.account);
+      } else {
+        var checked = deps.getCheckedAccounts();
+        account = checked.length > 0 ? checked[0] : null;
+      }
+      if (!account) {
+        return Promise.resolve({ content: [{ type: "text", text: "Error: No email account available." }] });
+      }
+
+      var client = getImapClient(account);
+      if (!client) {
+        return Promise.resolve({ content: [{ type: "text", text: "Error: IMAP module not available." }] });
+      }
+
+      var folder = args.folder || "INBOX";
+      var limit = Math.min(Math.max(args.limit || 20, 1), 50);
+
+      // Build IMAP search criteria
+      var criteria = {};
+      if (args.from) criteria.from = args.from;
+      if (args.subject) criteria.subject = args.subject;
+      if (args.text) criteria.body = args.text;
+      if (args.since) criteria.since = new Date(args.since);
+      if (args.before) criteria.before = new Date(args.before);
+      if (Object.keys(criteria).length === 0) criteria.all = true;
+
+      return client.connect().then(function () {
+        return client.getMailboxLock(folder);
+      }).then(function (lock) {
+        return client.search(criteria, { uid: true }).then(function (uids) {
+          if (!uids || uids.length === 0) {
+            lock.release();
+            return client.logout().then(function () {
+              return { content: [{ type: "text", text: JSON.stringify({ messages: [], total: 0 }, null, 2) }] };
+            });
+          }
+
+          var recentUids = uids.slice(-limit).reverse();
+
+          var fetchIter2 = client.fetch(recentUids, {
+            uid: true,
+            envelope: true,
+            flags: true,
+          }, { uid: true });
+          var messages = [];
+
+          function collect() {
+            return fetchIter2.next().then(function (result) {
+              if (result.done) return;
+              var msg = result.value;
+              var env = msg.envelope || {};
+              messages.push({
+                uid: msg.uid,
+                from: env.from && env.from[0] ? env.from[0].address : "",
+                subject: env.subject || "(no subject)",
+                date: env.date ? env.date.toISOString() : null,
+                unread: !msg.flags || !msg.flags.has("\\Seen"),
+              });
+              return collect();
+            });
+          }
+
+          return collect().then(function () {
+            lock.release();
+            return client.logout().then(function () {
+              return { content: [{ type: "text", text: JSON.stringify({ messages: messages, total: uids.length, account: account.email }, null, 2) }] };
+            });
+          });
+        });
+      }).catch(function (err) {
+        try { client.close(); } catch (e) {}
+        return { content: [{ type: "text", text: "Error searching email: " + (err.message || "Unknown error") }] };
+      });
+    }
+  ));
+
+  // --- clay_reply_email ---
+  tools.push(tool(
+    "clay_reply_email",
+    "Reply to an email by UID. Automatically sets In-Reply-To and References headers to preserve threading.",
+    buildShape({
+      account: { type: "string", description: "Email address of the account. If omitted, uses first checked account." },
+      uid: { type: "number", description: "Message UID to reply to (from clay_read_email results)" },
+      body: { type: "string", description: "Reply body text" },
+      reply_all: { type: "boolean", description: "Reply to all recipients (default false)" },
+      folder: { type: "string", description: "Folder/mailbox name (default: INBOX)" },
+    }, ["uid", "body"]),
+    function (args) {
+      var account;
+      if (args.account) {
+        account = deps.getAccountForTool(args.account);
+      } else {
+        var checked = deps.getCheckedAccounts();
+        account = checked.length > 0 ? checked[0] : null;
+      }
+      if (!account) {
+        return Promise.resolve({ content: [{ type: "text", text: "Error: No email account available." }] });
+      }
+
+      var client = getImapClient(account);
+      if (!client) {
+        return Promise.resolve({ content: [{ type: "text", text: "Error: IMAP module not available." }] });
+      }
+
+      var folder = args.folder || "INBOX";
+
+      return client.connect().then(function () {
+        return client.getMailboxLock(folder);
+      }).then(function (lock) {
+        return client.fetchOne(args.uid, {
+          uid: true,
+          envelope: true,
+        }, { uid: true }).then(function (msg) {
+          lock.release();
+          return client.logout().then(function () {
+            if (!msg || !msg.envelope) {
+              return { content: [{ type: "text", text: "Original message not found." }] };
+            }
+
+            var env = msg.envelope;
+            var replyTo = env.replyTo && env.replyTo[0] ? env.replyTo[0].address : (env.from && env.from[0] ? env.from[0].address : null);
+            if (!replyTo) {
+              return { content: [{ type: "text", text: "Cannot determine reply address from original message." }] };
+            }
+
+            var mailOpts = {
+              from: account.email,
+              to: replyTo,
+              subject: "Re: " + (env.subject || ""),
+              text: args.body,
+              inReplyTo: env.messageId || undefined,
+              references: env.messageId || undefined,
+            };
+
+            if (args.reply_all) {
+              var allTo = (env.to || []).map(function (a) { return a.address; }).filter(function (a) {
+                return a && a !== account.email;
+              });
+              var allCc = (env.cc || []).map(function (a) { return a.address; }).filter(function (a) {
+                return a && a !== account.email;
+              });
+              if (allTo.length > 0) mailOpts.to = [replyTo].concat(allTo).join(", ");
+              if (allCc.length > 0) mailOpts.cc = allCc.join(", ");
+            }
+
+            var transport = getPersonalTransport(account);
+            return transport.sendMail(mailOpts).then(function () {
+              try { transport.close(); } catch (e) {}
+              return { content: [{ type: "text", text: "Reply sent from " + account.email + " to " + mailOpts.to + ". Subject: " + mailOpts.subject }] };
+            });
+          });
+        });
+      }).catch(function (err) {
+        try { client.close(); } catch (e) {}
+        return { content: [{ type: "text", text: "Error replying to email: " + (err.message || "Unknown error") }] };
+      });
+    }
+  ));
+
+  // --- clay_list_labels ---
+  tools.push(tool(
+    "clay_list_labels",
+    "List all email folders/labels with message counts for an account.",
+    buildShape({
+      account: { type: "string", description: "Email address of the account. If omitted, uses first checked account." },
+    }, []),
+    function (args) {
+      var account;
+      if (args.account) {
+        account = deps.getAccountForTool(args.account);
+      } else {
+        var checked = deps.getCheckedAccounts();
+        account = checked.length > 0 ? checked[0] : null;
+      }
+      if (!account) {
+        return Promise.resolve({ content: [{ type: "text", text: "Error: No email account available." }] });
+      }
+
+      var client = getImapClient(account);
+      if (!client) {
+        return Promise.resolve({ content: [{ type: "text", text: "Error: IMAP module not available." }] });
+      }
+
+      return client.connect().then(function () {
+        return client.list();
+      }).then(function (mailboxes) {
+        var folders = mailboxes.map(function (mb) {
+          return {
+            name: mb.name,
+            path: mb.path,
+            delimiter: mb.delimiter,
+            flags: Array.from(mb.flags || []),
+            specialUse: mb.specialUse || null,
+          };
+        });
+        return client.logout().then(function () {
+          return { content: [{ type: "text", text: JSON.stringify({ folders: folders, account: account.email }, null, 2) }] };
+        });
+      }).catch(function (err) {
+        try { client.close(); } catch (e) {}
+        return { content: [{ type: "text", text: "Error listing folders: " + (err.message || "Unknown error") }] };
+      });
+    }
+  ));
+
+  // --- clay_mark_read ---
+  tools.push(tool(
+    "clay_mark_read",
+    "Mark one or more emails as read by UID.",
+    buildShape({
+      account: { type: "string", description: "Email address of the account. If omitted, uses first checked account." },
+      uids: { type: "string", description: "Comma-separated message UIDs to mark as read" },
+      folder: { type: "string", description: "Folder/mailbox name (default: INBOX)" },
+    }, ["uids"]),
+    function (args) {
+      var account;
+      if (args.account) {
+        account = deps.getAccountForTool(args.account);
+      } else {
+        var checked = deps.getCheckedAccounts();
+        account = checked.length > 0 ? checked[0] : null;
+      }
+      if (!account) {
+        return Promise.resolve({ content: [{ type: "text", text: "Error: No email account available." }] });
+      }
+
+      var client = getImapClient(account);
+      if (!client) {
+        return Promise.resolve({ content: [{ type: "text", text: "Error: IMAP module not available." }] });
+      }
+
+      var folder = args.folder || "INBOX";
+      var uidList = args.uids.split(",").map(function (s) { return parseInt(s.trim(), 10); }).filter(function (n) { return !isNaN(n); });
+
+      if (uidList.length === 0) {
+        return Promise.resolve({ content: [{ type: "text", text: "Error: No valid UIDs provided." }] });
+      }
+
+      return client.connect().then(function () {
+        return client.getMailboxLock(folder);
+      }).then(function (lock) {
+        return client.messageFlagsAdd(uidList, ["\\Seen"], { uid: true }).then(function () {
+          lock.release();
+          return client.logout().then(function () {
+            return { content: [{ type: "text", text: "Marked " + uidList.length + " message(s) as read in " + account.email + "/" + folder }] };
+          });
+        });
+      }).catch(function (err) {
+        try { client.close(); } catch (e) {}
+        return { content: [{ type: "text", text: "Error marking as read: " + (err.message || "Unknown error") }] };
+      });
+    }
+  ));
+
+  // --- clay_move_email ---
+  tools.push(tool(
+    "clay_move_email",
+    "Move one or more emails to a different folder/label by UID. Use clay_list_labels to see available folders. In Gmail, moving to a folder is equivalent to applying that label.",
+    buildShape({
+      account: { type: "string", description: "Email address of the account. If omitted, uses first checked account." },
+      uids: { type: "string", description: "Comma-separated message UIDs to move" },
+      from_folder: { type: "string", description: "Source folder (default: INBOX)" },
+      to_folder: { type: "string", description: "Destination folder/label name (e.g. 'Work', '[Gmail]/Trash', '[Gmail]/All Mail')" },
+    }, ["uids", "to_folder"]),
+    function (args) {
+      var account;
+      if (args.account) {
+        account = deps.getAccountForTool(args.account);
+      } else {
+        var checked = deps.getCheckedAccounts();
+        account = checked.length > 0 ? checked[0] : null;
+      }
+      if (!account) {
+        return Promise.resolve({ content: [{ type: "text", text: "Error: No email account available." }] });
+      }
+
+      var client = getImapClient(account);
+      if (!client) {
+        return Promise.resolve({ content: [{ type: "text", text: "Error: IMAP module not available." }] });
+      }
+
+      var fromFolder = args.from_folder || "INBOX";
+      var toFolder = args.to_folder;
+      var uidList = args.uids.split(",").map(function (s) { return parseInt(s.trim(), 10); }).filter(function (n) { return !isNaN(n); });
+
+      if (uidList.length === 0) {
+        return Promise.resolve({ content: [{ type: "text", text: "Error: No valid UIDs provided." }] });
+      }
+
+      return client.connect().then(function () {
+        return client.getMailboxLock(fromFolder);
+      }).then(function (lock) {
+        return client.messageMove(uidList, toFolder, { uid: true }).then(function () {
+          lock.release();
+          return client.logout().then(function () {
+            return { content: [{ type: "text", text: "Moved " + uidList.length + " message(s) from " + fromFolder + " to " + toFolder + " in " + account.email }] };
+          });
+        });
+      }).catch(function (err) {
+        try { client.close(); } catch (e) {}
+        return { content: [{ type: "text", text: "Error moving email: " + (err.message || "Unknown error") }] };
+      });
+    }
+  ));
+
+  return createSdkMcpServer({
+    name: "clay-email",
+    version: "1.0.0",
+    tools: tools,
+  });
+}
+
+module.exports = { create: create };