@agenticmail/enterprise 0.5.49 → 0.5.51

package/dist/index.js

@@ -35,7 +35,7 @@ import {
   executeTool,
   runAgentLoop,
   toolsToDefinitions
-} from "./chunk-6T5PE7NL.js";
+} from "./chunk-G7BBCWAX.js";
 import "./chunk-TYW5XTOW.js";
 import {
   ValidationError,
@@ -50,11 +50,11 @@ import {
   requireRole,
   securityHeaders,
   validate
-} from "./chunk-JFXH5PXO.js";
+} from "./chunk-Q4WDMWLJ.js";
 import {
   provision,
   runSetupWizard
-} from "./chunk-R3JR6Z3H.js";
+} from "./chunk-FKDN7ZV3.js";
 import {
   ENGINE_TABLES,
   ENGINE_TABLES_POSTGRES,
@@ -123,6 +123,734 @@ import "./chunk-KFQGP6VL.js";
 // src/engine/index.ts
 init_tool_catalog();
 init_guardrails();
+
+// src/agenticmail/providers/microsoft.ts
+var GRAPH_BASE = "https://graph.microsoft.com/v1.0";
+var MicrosoftEmailProvider = class {
+  provider = "microsoft";
+  identity = null;
+  get token() {
+    if (!this.identity) throw new Error("Not connected");
+    return this.identity.accessToken;
+  }
+  async refreshIfNeeded() {
+    if (this.identity?.refreshToken) {
+      this.identity.accessToken = await this.identity.refreshToken();
+    }
+  }
+  async graphFetch(path, opts) {
+    await this.refreshIfNeeded();
+    const res = await fetch(`${GRAPH_BASE}${path}`, {
+      ...opts,
+      headers: {
+        Authorization: `Bearer ${this.token}`,
+        "Content-Type": "application/json",
+        ...opts?.headers
+      }
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new Error(`Graph API ${res.status}: ${text}`);
+    }
+    if (res.status === 204) return null;
+    return res.json();
+  }
+  // ─── Connection ─────────────────────────────────────
+  async connect(identity) {
+    this.identity = identity;
+    await this.graphFetch("/me?$select=mail,displayName");
+  }
+  async disconnect() {
+    this.identity = null;
+  }
+  // ─── List / Read ────────────────────────────────────
+  async listMessages(folder, opts) {
+    const folderId = this.resolveFolderId(folder);
+    const top = opts?.limit || 20;
+    const skip = opts?.offset || 0;
+    const data = await this.graphFetch(
+      `/me/mailFolders/${folderId}/messages?$top=${top}&$skip=${skip}&$select=id,subject,from,toRecipients,receivedDateTime,isRead,flag,hasAttachments,bodyPreview&$orderby=receivedDateTime desc`
+    );
+    return (data.value || []).map((m) => this.toEnvelope(m));
+  }
+  async readMessage(uid) {
+    const data = await this.graphFetch(`/me/messages/${uid}?$select=id,subject,from,toRecipients,ccRecipients,bccRecipients,receivedDateTime,isRead,flag,hasAttachments,body,bodyPreview,replyTo,internetMessageId,internetMessageHeaders,conversationId`);
+    return this.toMessage(data);
+  }
+  async searchMessages(criteria) {
+    const filters = [];
+    if (criteria.from) filters.push(`from/emailAddress/address eq '${criteria.from}'`);
+    if (criteria.subject) filters.push(`contains(subject, '${criteria.subject}')`);
+    if (criteria.since) filters.push(`receivedDateTime ge ${criteria.since}`);
+    if (criteria.before) filters.push(`receivedDateTime lt ${criteria.before}`);
+    if (criteria.seen !== void 0) filters.push(`isRead eq ${criteria.seen}`);
+    let path = "/me/messages?$top=50&$select=id,subject,from,toRecipients,receivedDateTime,isRead,flag,hasAttachments,bodyPreview&$orderby=receivedDateTime desc";
+    if (filters.length) path += "&$filter=" + encodeURIComponent(filters.join(" and "));
+    if (criteria.text) path = `/me/messages?$search="${encodeURIComponent(criteria.text)}"&$top=50&$select=id,subject,from,toRecipients,receivedDateTime,isRead,flag,hasAttachments,bodyPreview`;
+    const data = await this.graphFetch(path);
+    return (data.value || []).map((m) => this.toEnvelope(m));
+  }
+  async listFolders() {
+    const data = await this.graphFetch("/me/mailFolders?$select=id,displayName,unreadItemCount,totalItemCount");
+    return (data.value || []).map((f) => ({
+      name: f.displayName,
+      path: f.id,
+      unread: f.unreadItemCount || 0,
+      total: f.totalItemCount || 0
+    }));
+  }
+  async createFolder(name) {
+    await this.graphFetch("/me/mailFolders", {
+      method: "POST",
+      body: JSON.stringify({ displayName: name })
+    });
+  }
+  // ─── Send ───────────────────────────────────────────
+  async send(options) {
+    const message = this.buildGraphMessage(options);
+    await this.graphFetch("/me/sendMail", {
+      method: "POST",
+      body: JSON.stringify({ message, saveToSentItems: true })
+    });
+    return { messageId: `graph-${Date.now()}` };
+  }
+  async reply(uid, body, replyAll = false) {
+    const endpoint = replyAll ? "replyAll" : "reply";
+    await this.graphFetch(`/me/messages/${uid}/${endpoint}`, {
+      method: "POST",
+      body: JSON.stringify({ comment: body })
+    });
+    return { messageId: `graph-reply-${Date.now()}` };
+  }
+  async forward(uid, to, body) {
+    await this.graphFetch(`/me/messages/${uid}/forward`, {
+      method: "POST",
+      body: JSON.stringify({
+        comment: body || "",
+        toRecipients: [{ emailAddress: { address: to } }]
+      })
+    });
+    return { messageId: `graph-fwd-${Date.now()}` };
+  }
+  // ─── Organize ───────────────────────────────────────
+  async moveMessage(uid, toFolder) {
+    const folderId = this.resolveFolderId(toFolder);
+    await this.graphFetch(`/me/messages/${uid}/move`, {
+      method: "POST",
+      body: JSON.stringify({ destinationId: folderId })
+    });
+  }
+  async deleteMessage(uid) {
+    await this.graphFetch(`/me/messages/${uid}`, { method: "DELETE" });
+  }
+  async markRead(uid) {
+    await this.graphFetch(`/me/messages/${uid}`, {
+      method: "PATCH",
+      body: JSON.stringify({ isRead: true })
+    });
+  }
+  async markUnread(uid) {
+    await this.graphFetch(`/me/messages/${uid}`, {
+      method: "PATCH",
+      body: JSON.stringify({ isRead: false })
+    });
+  }
+  async flagMessage(uid) {
+    await this.graphFetch(`/me/messages/${uid}`, {
+      method: "PATCH",
+      body: JSON.stringify({ flag: { flagStatus: "flagged" } })
+    });
+  }
+  async unflagMessage(uid) {
+    await this.graphFetch(`/me/messages/${uid}`, {
+      method: "PATCH",
+      body: JSON.stringify({ flag: { flagStatus: "notFlagged" } })
+    });
+  }
+  // ─── Batch ──────────────────────────────────────────
+  async batchMarkRead(uids) {
+    await Promise.all(uids.map((uid) => this.markRead(uid)));
+  }
+  async batchMarkUnread(uids) {
+    await Promise.all(uids.map((uid) => this.markUnread(uid)));
+  }
+  async batchMove(uids, toFolder) {
+    await Promise.all(uids.map((uid) => this.moveMessage(uid, toFolder)));
+  }
+  async batchDelete(uids) {
+    await Promise.all(uids.map((uid) => this.deleteMessage(uid)));
+  }
+  // ─── Helpers ────────────────────────────────────────
+  resolveFolderId(folder) {
+    const map = {
+      INBOX: "inbox",
+      inbox: "inbox",
+      Sent: "sentItems",
+      sent: "sentItems",
+      sentitems: "sentItems",
+      Drafts: "drafts",
+      drafts: "drafts",
+      Trash: "deletedItems",
+      trash: "deletedItems",
+      deleteditems: "deletedItems",
+      Junk: "junkemail",
+      junk: "junkemail",
+      spam: "junkemail",
+      Archive: "archive",
+      archive: "archive"
+    };
+    return map[folder] || folder;
+  }
+  buildGraphMessage(options) {
+    const msg = {
+      subject: options.subject,
+      body: { contentType: options.html ? "HTML" : "Text", content: options.html || options.body },
+      toRecipients: options.to.split(",").map((e) => ({ emailAddress: { address: e.trim() } }))
+    };
+    if (options.cc) msg.ccRecipients = options.cc.split(",").map((e) => ({ emailAddress: { address: e.trim() } }));
+    if (options.bcc) msg.bccRecipients = options.bcc.split(",").map((e) => ({ emailAddress: { address: e.trim() } }));
+    if (options.inReplyTo) msg.internetMessageHeaders = [{ name: "In-Reply-To", value: options.inReplyTo }];
+    return msg;
+  }
+  toEnvelope(m) {
+    return {
+      uid: m.id,
+      from: { name: m.from?.emailAddress?.name, email: m.from?.emailAddress?.address || "" },
+      to: (m.toRecipients || []).map((r) => ({ name: r.emailAddress?.name, email: r.emailAddress?.address || "" })),
+      subject: m.subject || "",
+      date: m.receivedDateTime || "",
+      read: !!m.isRead,
+      flagged: m.flag?.flagStatus === "flagged",
+      hasAttachments: !!m.hasAttachments,
+      preview: m.bodyPreview || ""
+    };
+  }
+  toMessage(m) {
+    return {
+      uid: m.id,
+      from: { name: m.from?.emailAddress?.name, email: m.from?.emailAddress?.address || "" },
+      to: (m.toRecipients || []).map((r) => ({ name: r.emailAddress?.name, email: r.emailAddress?.address || "" })),
+      cc: (m.ccRecipients || []).map((r) => ({ name: r.emailAddress?.name, email: r.emailAddress?.address || "" })),
+      subject: m.subject || "",
+      body: m.body?.contentType === "HTML" ? "" : m.body?.content || "",
+      html: m.body?.contentType === "HTML" ? m.body?.content : void 0,
+      date: m.receivedDateTime || "",
+      read: !!m.isRead,
+      flagged: m.flag?.flagStatus === "flagged",
+      folder: "inbox",
+      messageId: m.internetMessageId,
+      attachments: []
+    };
+  }
+};
+
+// src/agenticmail/providers/google.ts
+var GMAIL_BASE = "https://gmail.googleapis.com/gmail/v1";
+var GoogleEmailProvider = class {
+  provider = "google";
+  identity = null;
+  userId = "me";
+  get token() {
+    if (!this.identity) throw new Error("Not connected");
+    return this.identity.accessToken;
+  }
+  async refreshIfNeeded() {
+    if (this.identity?.refreshToken) {
+      this.identity.accessToken = await this.identity.refreshToken();
+    }
+  }
+  async gmailFetch(path, opts) {
+    await this.refreshIfNeeded();
+    const res = await fetch(`${GMAIL_BASE}/users/${this.userId}${path}`, {
+      ...opts,
+      headers: {
+        Authorization: `Bearer ${this.token}`,
+        "Content-Type": "application/json",
+        ...opts?.headers
+      }
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new Error(`Gmail API ${res.status}: ${text}`);
+    }
+    if (res.status === 204) return null;
+    return res.json();
+  }
+  // ─── Connection ─────────────────────────────────────
+  async connect(identity) {
+    this.identity = identity;
+    await this.gmailFetch("/profile");
+  }
+  async disconnect() {
+    this.identity = null;
+  }
+  // ─── List / Read ────────────────────────────────────
+  async listMessages(folder, opts) {
+    const labelId = this.resolveLabelId(folder);
+    const maxResults = opts?.limit || 20;
+    const q = labelId === "INBOX" ? "" : "";
+    const data = await this.gmailFetch(`/messages?labelIds=${labelId}&maxResults=${maxResults}${q ? "&q=" + encodeURIComponent(q) : ""}`);
+    if (!data.messages?.length) return [];
+    const envelopes = [];
+    for (const msg of data.messages) {
+      try {
+        const detail = await this.gmailFetch(`/messages/${msg.id}?format=metadata&metadataHeaders=From&metadataHeaders=To&metadataHeaders=Subject&metadataHeaders=Date`);
+        envelopes.push(this.metadataToEnvelope(detail));
+      } catch {
+      }
+    }
+    return envelopes;
+  }
+  async readMessage(uid) {
+    const data = await this.gmailFetch(`/messages/${uid}?format=full`);
+    return this.fullToMessage(data);
+  }
+  async searchMessages(criteria) {
+    const parts = [];
+    if (criteria.from) parts.push(`from:${criteria.from}`);
+    if (criteria.to) parts.push(`to:${criteria.to}`);
+    if (criteria.subject) parts.push(`subject:${criteria.subject}`);
+    if (criteria.text) parts.push(criteria.text);
+    if (criteria.since) parts.push(`after:${criteria.since.split("T")[0]}`);
+    if (criteria.before) parts.push(`before:${criteria.before.split("T")[0]}`);
+    if (criteria.seen === true) parts.push("is:read");
+    if (criteria.seen === false) parts.push("is:unread");
+    const q = parts.join(" ");
+    const data = await this.gmailFetch(`/messages?q=${encodeURIComponent(q)}&maxResults=50`);
+    if (!data.messages?.length) return [];
+    const envelopes = [];
+    for (const msg of data.messages.slice(0, 20)) {
+      try {
+        const detail = await this.gmailFetch(`/messages/${msg.id}?format=metadata&metadataHeaders=From&metadataHeaders=To&metadataHeaders=Subject&metadataHeaders=Date`);
+        envelopes.push(this.metadataToEnvelope(detail));
+      } catch {
+      }
+    }
+    return envelopes;
+  }
+  async listFolders() {
+    const data = await this.gmailFetch("/labels");
+    return (data.labels || []).map((l) => ({
+      name: l.name,
+      path: l.id,
+      unread: l.messagesUnread || 0,
+      total: l.messagesTotal || 0
+    }));
+  }
+  async createFolder(name) {
+    await this.gmailFetch("/labels", {
+      method: "POST",
+      body: JSON.stringify({ name, labelListVisibility: "labelShow", messageListVisibility: "show" })
+    });
+  }
+  // ─── Send ───────────────────────────────────────────
+  async send(options) {
+    const raw = this.buildRawEmail(options);
+    const data = await this.gmailFetch("/messages/send", {
+      method: "POST",
+      body: JSON.stringify({ raw })
+    });
+    return { messageId: data.id };
+  }
+  async reply(uid, body, replyAll = false) {
+    const original = await this.readMessage(uid);
+    const to = replyAll ? [original.from.email, ...(original.to || []).map((t) => t.email), ...(original.cc || []).map((c) => c.email)].filter((e) => e !== this.identity?.email).join(", ") : original.from.email;
+    return this.send({
+      to,
+      subject: original.subject.startsWith("Re:") ? original.subject : `Re: ${original.subject}`,
+      body,
+      inReplyTo: original.messageId,
+      references: original.references ? [...original.references, original.messageId] : [original.messageId]
+    });
+  }
+  async forward(uid, to, body) {
+    const original = await this.readMessage(uid);
+    return this.send({
+      to,
+      subject: `Fwd: ${original.subject}`,
+      body: (body ? body + "\n\n" : "") + `---------- Forwarded message ----------
+From: ${original.from.email}
+Date: ${original.date}
+Subject: ${original.subject}
+
+${original.body}`
+    });
+  }
+  // ─── Organize ───────────────────────────────────────
+  async moveMessage(uid, toFolder, fromFolder) {
+    const addLabel = this.resolveLabelId(toFolder);
+    const removeLabel = fromFolder ? this.resolveLabelId(fromFolder) : "INBOX";
+    await this.gmailFetch(`/messages/${uid}/modify`, {
+      method: "POST",
+      body: JSON.stringify({ addLabelIds: [addLabel], removeLabelIds: [removeLabel] })
+    });
+  }
+  async deleteMessage(uid) {
+    await this.gmailFetch(`/messages/${uid}/trash`, { method: "POST" });
+  }
+  async markRead(uid) {
+    await this.gmailFetch(`/messages/${uid}/modify`, {
+      method: "POST",
+      body: JSON.stringify({ removeLabelIds: ["UNREAD"] })
+    });
+  }
+  async markUnread(uid) {
+    await this.gmailFetch(`/messages/${uid}/modify`, {
+      method: "POST",
+      body: JSON.stringify({ addLabelIds: ["UNREAD"] })
+    });
+  }
+  async flagMessage(uid) {
+    await this.gmailFetch(`/messages/${uid}/modify`, {
+      method: "POST",
+      body: JSON.stringify({ addLabelIds: ["STARRED"] })
+    });
+  }
+  async unflagMessage(uid) {
+    await this.gmailFetch(`/messages/${uid}/modify`, {
+      method: "POST",
+      body: JSON.stringify({ removeLabelIds: ["STARRED"] })
+    });
+  }
+  // ─── Batch ──────────────────────────────────────────
+  async batchMarkRead(uids) {
+    await this.gmailFetch("/messages/batchModify", {
+      method: "POST",
+      body: JSON.stringify({ ids: uids, removeLabelIds: ["UNREAD"] })
+    });
+  }
+  async batchMarkUnread(uids) {
+    await this.gmailFetch("/messages/batchModify", {
+      method: "POST",
+      body: JSON.stringify({ ids: uids, addLabelIds: ["UNREAD"] })
+    });
+  }
+  async batchMove(uids, toFolder, fromFolder) {
+    const addLabel = this.resolveLabelId(toFolder);
+    const removeLabel = fromFolder ? this.resolveLabelId(fromFolder) : "INBOX";
+    await this.gmailFetch("/messages/batchModify", {
+      method: "POST",
+      body: JSON.stringify({ ids: uids, addLabelIds: [addLabel], removeLabelIds: [removeLabel] })
+    });
+  }
+  async batchDelete(uids) {
+    await Promise.all(uids.map((uid) => this.deleteMessage(uid)));
+  }
+  // ─── Helpers ────────────────────────────────────────
+  resolveLabelId(folder) {
+    const map = {
+      INBOX: "INBOX",
+      inbox: "INBOX",
+      Sent: "SENT",
+      sent: "SENT",
+      Drafts: "DRAFT",
+      drafts: "DRAFT",
+      Trash: "TRASH",
+      trash: "TRASH",
+      Spam: "SPAM",
+      spam: "SPAM",
+      Junk: "SPAM",
+      junk: "SPAM",
+      Starred: "STARRED",
+      starred: "STARRED",
+      Important: "IMPORTANT",
+      important: "IMPORTANT"
+    };
+    return map[folder] || folder;
+  }
+  buildRawEmail(options) {
+    const lines = [
+      `To: ${options.to}`,
+      `Subject: ${options.subject}`,
+      `Content-Type: text/plain; charset=utf-8`
+    ];
+    if (options.cc) lines.splice(1, 0, `Cc: ${options.cc}`);
+    if (options.inReplyTo) lines.push(`In-Reply-To: ${options.inReplyTo}`);
+    if (options.references?.length) lines.push(`References: ${options.references.join(" ")}`);
+    lines.push("", options.body);
+    const raw = lines.join("\r\n");
+    return btoa(unescape(encodeURIComponent(raw))).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+  }
+  getHeader(msg, name) {
+    const headers = msg.payload?.headers || [];
+    const h = headers.find((h2) => h2.name.toLowerCase() === name.toLowerCase());
+    return h?.value || "";
+  }
+  metadataToEnvelope(msg) {
+    const from = this.getHeader(msg, "From");
+    const fromMatch = from.match(/^(.*?)\s*<(.+?)>$/) || [null, "", from];
+    return {
+      uid: msg.id,
+      from: { name: fromMatch[1]?.replace(/"/g, "").trim() || void 0, email: fromMatch[2] || from },
+      to: [{ email: this.getHeader(msg, "To") }],
+      subject: this.getHeader(msg, "Subject"),
+      date: this.getHeader(msg, "Date"),
+      read: !(msg.labelIds || []).includes("UNREAD"),
+      flagged: (msg.labelIds || []).includes("STARRED"),
+      hasAttachments: false,
+      preview: msg.snippet || ""
+    };
+  }
+  fullToMessage(msg) {
+    const from = this.getHeader(msg, "From");
+    const fromMatch = from.match(/^(.*?)\s*<(.+?)>$/) || [null, "", from];
+    let body = "";
+    let html;
+    const extractBody = (payload) => {
+      if (payload.mimeType === "text/plain" && payload.body?.data) {
+        body = Buffer.from(payload.body.data, "base64url").toString("utf-8");
+      }
+      if (payload.mimeType === "text/html" && payload.body?.data) {
+        html = Buffer.from(payload.body.data, "base64url").toString("utf-8");
+      }
+      if (payload.parts) payload.parts.forEach(extractBody);
+    };
+    if (msg.payload) extractBody(msg.payload);
+    return {
+      uid: msg.id,
+      from: { name: fromMatch[1]?.replace(/"/g, "").trim() || void 0, email: fromMatch[2] || from },
+      to: [{ email: this.getHeader(msg, "To") }],
+      cc: this.getHeader(msg, "Cc") ? [{ email: this.getHeader(msg, "Cc") }] : void 0,
+      subject: this.getHeader(msg, "Subject"),
+      body,
+      html,
+      date: this.getHeader(msg, "Date"),
+      read: !(msg.labelIds || []).includes("UNREAD"),
+      flagged: (msg.labelIds || []).includes("STARRED"),
+      folder: (msg.labelIds || []).includes("INBOX") ? "inbox" : "other",
+      messageId: this.getHeader(msg, "Message-ID"),
+      inReplyTo: this.getHeader(msg, "In-Reply-To") || void 0,
+      references: this.getHeader(msg, "References") ? this.getHeader(msg, "References").split(/\s+/) : void 0,
+      attachments: []
+    };
+  }
+};
+
+// src/agenticmail/providers/index.ts
+function createEmailProvider(provider) {
+  switch (provider) {
+    case "microsoft":
+      return new MicrosoftEmailProvider();
+    case "google":
+      return new GoogleEmailProvider();
+    case "imap":
+      throw new Error("Generic IMAP provider not yet implemented \u2014 use Microsoft or Google");
+    default:
+      throw new Error(`Unknown email provider: ${provider}`);
+  }
+}
+
+// src/agenticmail/manager.ts
+var AgenticMailManager = class {
+  providers = /* @__PURE__ */ new Map();
+  identities = /* @__PURE__ */ new Map();
+  db;
+  constructor(opts) {
+    this.db = opts?.db;
+  }
+  setDb(db) {
+    this.db = db;
+  }
+  // ─── Agent Registration ─────────────────────────────
+  /**
+   * Register an agent's email identity from the org's OAuth/SSO.
+   * Called when an agent is created or when its OAuth token is refreshed.
+   */
+  async registerAgent(identity) {
+    this.identities.set(identity.agentId, identity);
+    const provider = createEmailProvider(identity.provider);
+    await provider.connect(identity);
+    this.providers.set(identity.agentId, provider);
+  }
+  /**
+   * Unregister an agent (on deletion or token revocation).
+   */
+  async unregisterAgent(agentId) {
+    const provider = this.providers.get(agentId);
+    if (provider) {
+      await provider.disconnect().catch(() => {
+      });
+      this.providers.delete(agentId);
+    }
+    this.identities.delete(agentId);
+  }
+  /**
+   * Get the email provider for an agent.
+   * Throws if agent is not registered.
+   */
+  getProvider(agentId) {
+    const provider = this.providers.get(agentId);
+    if (!provider) throw new Error(`Agent ${agentId} has no email provider registered. Ensure the agent has been connected via org OAuth.`);
+    return provider;
+  }
+  /**
+   * Get the email identity for an agent.
+   */
+  getIdentity(agentId) {
+    return this.identities.get(agentId);
+  }
+  /**
+   * Check if an agent has email access.
+   */
+  hasEmail(agentId) {
+    return this.providers.has(agentId);
+  }
+  // ─── Inter-Agent Messaging ──────────────────────────
+  // These use the enterprise DB directly, not email.
+  // Agents in the same org can message each other without email.
+  /**
+   * Send a message from one agent to another (internal, no email).
+   */
+  async sendAgentMessage(from, to, subject, body, priority = "normal") {
+    const msg = {
+      id: crypto.randomUUID(),
+      from,
+      to,
+      subject,
+      body,
+      priority,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      read: false
+    };
+    if (this.db) {
+      await this.db.execute(
+        `INSERT INTO agent_messages (id, from_agent, to_agent, subject, body, priority, created_at, read)
+         VALUES (?, ?, ?, ?, ?, ?, ?, 0)`,
+        [msg.id, msg.from, msg.to, msg.subject, msg.body, msg.priority, msg.createdAt]
+      ).catch(() => {
+      });
+    }
+    return msg;
+  }
+  /**
+   * Get unread messages for an agent.
+   */
+  async getAgentMessages(agentId, opts) {
+    if (!this.db) return [];
+    try {
+      let sql = "SELECT * FROM agent_messages WHERE to_agent = ?";
+      const params = [agentId];
+      if (opts?.unreadOnly) {
+        sql += " AND read = 0";
+      }
+      sql += " ORDER BY created_at DESC LIMIT ?";
+      params.push(opts?.limit || 20);
+      const rows = await this.db.query(sql, params);
+      return rows.map((r) => ({
+        id: r.id,
+        from: r.from_agent,
+        to: r.to_agent,
+        subject: r.subject,
+        body: r.body,
+        priority: r.priority,
+        createdAt: r.created_at,
+        read: !!r.read
+      }));
+    } catch {
+      return [];
+    }
+  }
+  // ─── Task Management ────────────────────────────────
+  // Tasks also use the enterprise DB directly.
+  /**
+   * Create a task assigned to an agent.
+   */
+  async createTask(assigner, assignee, title, description, priority = "normal") {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const task = {
+      id: crypto.randomUUID(),
+      assigner,
+      assignee,
+      title,
+      description,
+      status: "pending",
+      priority,
+      createdAt: now,
+      updatedAt: now
+    };
+    if (this.db) {
+      await this.db.execute(
+        `INSERT INTO agent_tasks (id, assigner, assignee, title, description, status, priority, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        [task.id, task.assigner, task.assignee, task.title, task.description || null, task.status, task.priority, task.createdAt, task.updatedAt]
+      ).catch(() => {
+      });
+    }
+    return task;
+  }
+  /**
+   * Get tasks for an agent.
+   */
+  async getAgentTasks(agentId, direction = "incoming", status) {
+    if (!this.db) return [];
+    try {
+      const col = direction === "incoming" ? "assignee" : "assigner";
+      let sql = `SELECT * FROM agent_tasks WHERE ${col} = ?`;
+      const params = [agentId];
+      if (status) {
+        sql += " AND status = ?";
+        params.push(status);
+      }
+      sql += " ORDER BY created_at DESC LIMIT 50";
+      const rows = await this.db.query(sql, params);
+      return rows.map((r) => ({
+        id: r.id,
+        assigner: r.assigner,
+        assignee: r.assignee,
+        title: r.title,
+        description: r.description,
+        status: r.status,
+        priority: r.priority,
+        result: r.result ? JSON.parse(r.result) : void 0,
+        createdAt: r.created_at,
+        updatedAt: r.updated_at
+      }));
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Update task status.
+   */
+  async updateTask(taskId, updates) {
+    if (!this.db) return;
+    const sets = ["updated_at = ?"];
+    const params = [(/* @__PURE__ */ new Date()).toISOString()];
+    if (updates.status) {
+      sets.push("status = ?");
+      params.push(updates.status);
+    }
+    if (updates.result !== void 0) {
+      sets.push("result = ?");
+      params.push(JSON.stringify(updates.result));
+    }
+    params.push(taskId);
+    await this.db.execute(`UPDATE agent_tasks SET ${sets.join(", ")} WHERE id = ?`, params).catch(() => {
+    });
+  }
+  // ─── Lifecycle ──────────────────────────────────────
+  /**
+   * Get all registered agents and their email status.
+   */
+  getRegisteredAgents() {
+    const agents = [];
+    for (const [agentId, identity] of this.identities) {
+      agents.push({ agentId, email: identity.email, provider: identity.provider });
+    }
+    return agents;
+  }
+  /**
+   * Shutdown — disconnect all providers.
+   */
+  async shutdown() {
+    for (const provider of this.providers.values()) {
+      await provider.disconnect().catch(() => {
+      });
+    }
+    this.providers.clear();
+    this.identities.clear();
+  }
+};
 export {
   AGENTICMAIL_TOOLS,
   ALL_TOOLS,
@@ -133,6 +861,7 @@ export {
   AgentLifecycleManager,
   AgentMemoryManager,
   AgentRuntime,
+  AgenticMailManager,
   ApprovalEngine,
   BUILTIN_SKILLS,
   CORE_TOOLS,
@@ -148,6 +877,7 @@ export {
   EmailChannel,
   EngineDatabase,
   FollowUpScheduler,
+  GoogleEmailProvider,
   GuardrailEngine,
   HealthMonitor,
   KeyedRateLimiter,
@@ -155,6 +885,7 @@ export {
   MIGRATIONS,
   MIGRATIONS_TABLE,
   MIGRATIONS_TABLE_POSTGRES,
+  MicrosoftEmailProvider,
   OnboardingManager,
   OrgPolicyEngine,
   PLAN_LIMITS,
@@ -183,6 +914,7 @@ export {
   createAdminRoutes,
   createAgentRuntime,
   createAuthRoutes,
+  createEmailProvider,
   createNoopHooks,
   createRuntimeHooks,
   createServer,