@agenticmail/enterprise 0.5.153 → 0.5.155

package/dist/cli.js

@@ -50,7 +50,7 @@ Skill Development:
     import("./cli-serve-DHVSPFW5.js").then((m) => m.runServe(args.slice(1))).catch(fatal);
     break;
   case "agent":
-    import("./cli-agent-7TWEYMAP.js").then((m) => m.runAgent(args.slice(1))).catch(fatal);
+    import("./cli-agent-VNXOYV4K.js").then((m) => m.runAgent(args.slice(1))).catch(fatal);
     break;
   case "setup":
   default:

package/dist/index.js

@@ -84,7 +84,7 @@ import {
   GoogleEmailProvider,
   MicrosoftEmailProvider,
   createEmailProvider
-} from "./chunk-VEPWCYAL.js";
+} from "./chunk-HKCKMCPY.js";
 import "./chunk-RO537U6H.js";
 import "./chunk-DRXMYYKN.js";
 import {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agenticmail/enterprise",
-  "version": "0.5.153",
+  "version": "0.5.155",
   "description": "AgenticMail Enterprise — cloud-hosted AI agent identity, email, auth & compliance for organizations",
   "type": "module",
   "bin": {

package/src/agenticmail/providers/google.ts

@@ -50,10 +50,14 @@ export class GoogleEmailProvider implements IEmailProvider {
 
   // ─── Connection ─────────────────────────────────────
 
+  /** Last known historyId — used for efficient polling via history.list */
+  public lastHistoryId: string = '';
+
   async connect(identity: AgentEmailIdentity): Promise<void> {
     this.identity = identity;
-    // Validate token
-    await this.gmailFetch('/profile');
+    // Validate token and capture historyId
+    const profile = await this.gmailFetch('/profile');
+    this.lastHistoryId = profile.historyId || '';
   }
 
   async disconnect(): Promise<void> {

package/src/cli-agent.ts

@@ -577,13 +577,19 @@ async function startEmailPolling(
   } catch {}
 
   // Initial load — mark existing messages as processed so we don't reply to old emails
+  // Also capture historyId for Gmail History API polling
+  let lastHistoryId = '';
   try {
     console.log('[email-poll] Loading existing messages...');
     const existing = await emailProvider.listMessages('INBOX', { limit: 50 });
     for (const msg of existing) {
       processedIds.add(msg.uid);
     }
-    console.log(`[email-poll] Loaded ${processedIds.size} existing messages (will skip)`);
+    // Get historyId from Google provider if available
+    if ('lastHistoryId' in emailProvider) {
+      lastHistoryId = (emailProvider as any).lastHistoryId || '';
+    }
+    console.log(`[email-poll] Loaded ${processedIds.size} existing messages (will skip)${lastHistoryId ? `, historyId: ${lastHistoryId}` : ''}`);
   } catch (e: any) {
     console.error(`[email-poll] Failed to load existing messages: ${e.message}`);
   }
@@ -593,31 +599,67 @@ async function startEmailPolling(
   // Poll loop
   const POLL_INTERVAL = 30_000; // 30 seconds
   const agentEmail = (emailConfig.email || config.email?.address || '').toLowerCase();
+  const useHistoryApi = 'getHistory' in emailProvider && !!lastHistoryId;
+  if (useHistoryApi) console.log('[email-poll] Using Gmail History API for reliable change detection');
 
   async function pollOnce() {
     try {
-      // Search for recent emails using after: filter (Gmail API can have eventual consistency delays)
-      const today = new Date().toISOString().split('T')[0]; // YYYY-MM-DD
-      const recentSearch = await emailProvider.searchMessages({ since: today }).catch(() => [] as any[]);
-      const inboxList = await emailProvider.listMessages('INBOX', { limit: 50 });
-      // Combine and deduplicate
-      const seenUids = new Set<string>();
-      const msgs: typeof inboxList = [];
-      for (const m of [...(recentSearch || []), ...inboxList]) {
-        if (!seenUids.has(m.uid)) { seenUids.add(m.uid); msgs.push(m); }
+      let newMessageIds: string[] = [];
+
+      if (useHistoryApi && lastHistoryId) {
+        // Use Gmail History API — most reliable for detecting new messages
+        try {
+          const history = await (emailProvider as any).getHistory(lastHistoryId);
+          if (history.historyId) lastHistoryId = history.historyId;
+          // Filter to only messages we haven't processed
+          newMessageIds = history.messages
+            .map((m: any) => m.id)
+            .filter((id: string) => !processedIds.has(id));
+          if (newMessageIds.length > 0) {
+            console.log(`[email-poll] History API: ${newMessageIds.length} new messages since historyId ${lastHistoryId}`);
+          }
+        } catch (histErr: any) {
+          // historyId might be too old (404), fall back to list
+          console.warn(`[email-poll] History API failed (${histErr.message?.slice(0, 60)}), falling back to list`);
+          const msgs = await emailProvider.listMessages('INBOX', { limit: 50 });
+          newMessageIds = msgs.filter(m => !processedIds.has(m.uid)).map(m => m.uid);
+          // Update historyId from provider
+          if ('lastHistoryId' in emailProvider) lastHistoryId = (emailProvider as any).lastHistoryId || lastHistoryId;
+        }
+      } else {
+        // Fallback: list + search combo
+        const today = new Date().toISOString().split('T')[0];
+        const recentSearch = await emailProvider.searchMessages({ since: today }).catch(() => [] as any[]);
+        const inboxList = await emailProvider.listMessages('INBOX', { limit: 50 });
+        const seenUids = new Set<string>();
+        const combined: string[] = [];
+        for (const m of [...(recentSearch || []), ...inboxList]) {
+          if (!seenUids.has(m.uid) && !processedIds.has(m.uid)) { seenUids.add(m.uid); combined.push(m.uid); }
+        }
+        newMessageIds = combined;
       }
-      const newMessages = msgs.filter(m => !processedIds.has(m.uid));
-      if (newMessages.length > 0) {
-        console.log(`[email-poll] Found ${newMessages.length} new messages (${msgs.length} total, ${processedIds.size} known)`);
-      } else if (msgs.length < processedIds.size) {
-        console.log(`[email-poll] No new (${msgs.length} fetched < ${processedIds.size} known — possible API gap)`);
+
+      if (newMessageIds.length > 0) {
+        console.log(`[email-poll] Processing ${newMessageIds.length} new messages`);
       }
 
-      for (const envelope of newMessages) {
-        processedIds.add(envelope.uid);
+      for (const msgId of newMessageIds) {
+        processedIds.add(msgId);
+
+        // Read full message
+        let fullMsg: any;
+        try {
+          fullMsg = await emailProvider.readMessage(msgId, 'INBOX');
+        } catch (readErr: any) {
+          console.warn(`[email-poll] Failed to read message ${msgId}: ${readErr.message?.slice(0, 80)}`);
+          continue;
+        }
+        const envelope = { uid: msgId, from: fullMsg.from, to: fullMsg.to, subject: fullMsg.subject, date: fullMsg.date };
 
         // Skip emails from ourselves
-        if (envelope.from?.email?.toLowerCase() === agentEmail) continue;
+        if (envelope.from?.email?.toLowerCase() === agentEmail) {
+          continue;
+        }
 
         console.log(`[email-poll] New email from ${envelope.from?.email}: "${envelope.subject}"`);
 
@@ -632,14 +674,11 @@ async function startEmailPolling(
           console.warn(`[email-poll] Failed to persist processed ID: ${peErr.message}`);
         }
 
-        // Read full message
-        const fullMsg = await emailProvider.readMessage(envelope.uid, 'INBOX');
-
         // Mark as read
-        try { await emailProvider.markRead(envelope.uid, 'INBOX'); } catch {}
+        try { await emailProvider.markRead(msgId, 'INBOX'); } catch {}
 
         // Format as agent message and spawn a session
-        const emailUid = envelope.uid;
+        const emailUid = msgId;
         const emailText = [
           `[Inbound Email]`,
           `Message-ID: ${emailUid}`,