@vellumai/assistant 0.6.2 → 0.6.4

package/src/config/bundled-skills/gmail/tools/gmail-archive.ts

@@ -8,12 +8,49 @@ import type {
   ToolContext,
   ToolExecutionResult,
 } from "../../../../tools/types.js";
+import { addToBlocklist } from "./gmail-preferences.js";
 import { getSenderMessageIds } from "./scan-result-store.js";
 import { err, ok } from "./shared.js";
 
 const BATCH_MODIFY_LIMIT = 1000;
 const MAX_MESSAGES = 5000;
 
+function decodeSenderEmail(senderId: string): string | null {
+  try {
+    return Buffer.from(senderId, "base64url").toString("utf-8");
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Persist archived sender emails to the blocklist for future sessions.
+ * Only runs when the archive was initiated via a validated scan_id path
+ * (not bare message_ids) to prevent unverified emails from being recorded.
+ */
+function recordBlocklist(
+  scanId: string | undefined,
+  senderIds: string[] | undefined,
+): void {
+  if (!scanId || !senderIds?.length) return;
+  const archivedEmails: string[] = [];
+  for (const sid of senderIds) {
+    try {
+      const email = Buffer.from(sid, "base64url").toString("utf-8");
+      if (email.includes("@")) archivedEmails.push(email);
+    } catch {
+      // Skip undecodable sender IDs
+    }
+  }
+  if (archivedEmails.length > 0) {
+    try {
+      addToBlocklist(archivedEmails);
+    } catch {
+      // Non-fatal — preferences are best-effort
+    }
+  }
+}
+
 export async function run(
   input: Record<string, unknown>,
   context: ToolContext,
@@ -28,9 +65,9 @@ export async function run(
   // Resolve message IDs via priority: query → scan_id+sender_ids → message_ids → message_id
   if (query) {
     // Query path requires surface action confirmation
-    if (!context.triggeredBySurfaceAction) {
+    if (!context.triggeredBySurfaceAction && !context.batchAuthorizedByTask) {
       return err(
-        "This tool requires user confirmation via a surface action. Present results in a selection table with action buttons and wait for the user to click before proceeding.",
+        "This tool requires either a surface action or a scheduled task run with this tool in required_tools. Present results in a selection table with action buttons and wait for the user to click before proceeding.",
       );
     }
 
@@ -83,24 +120,92 @@ export async function run(
     }
   } else if (scanId && senderIds?.length) {
     // Scan path requires surface action confirmation
-    if (!context.triggeredBySurfaceAction) {
+    if (!context.triggeredBySurfaceAction && !context.batchAuthorizedByTask) {
       return err(
-        "This tool requires user confirmation via a surface action. Present results in a selection table with action buttons and wait for the user to click before proceeding.",
+        "This tool requires either a surface action or a scheduled task run with this tool in required_tools. Present results in a selection table with action buttons and wait for the user to click before proceeding.",
       );
     }
 
     const resolved = getSenderMessageIds(scanId, senderIds);
-    if (!resolved) {
+    if (resolved !== null && resolved.length > 0) {
+      messageIds = resolved;
+    } else if (resolved === null) {
+      // Scan expired or sender IDs unresolved — fall back to query-based archiving
+      const emails: string[] = [];
+      const undecodable: string[] = [];
+      for (const sid of senderIds) {
+        const email = decodeSenderEmail(sid);
+        if (email && email.includes("@")) {
+          emails.push(email);
+        } else {
+          undecodable.push(sid);
+        }
+      }
+
+      if (emails.length === 0) {
+        return err(
+          "Scan results have expired and sender IDs could not be decoded. Please re-run the scan.",
+        );
+      }
+
+      try {
+        const connection = await resolveOAuthConnection("google", {
+          account,
+        });
+        const allMessageIds: string[] = [];
+
+        for (const email of emails) {
+          const fallbackQuery = `from:"${email.replace(/"/g, "")}" in:inbox`;
+          let pageToken: string | undefined;
+          while (allMessageIds.length < MAX_MESSAGES) {
+            const listResp = await listMessages(
+              connection,
+              fallbackQuery,
+              Math.min(500, MAX_MESSAGES - allMessageIds.length),
+              pageToken,
+            );
+            const ids = (listResp.messages ?? []).map((m) => m.id);
+            if (ids.length === 0) break;
+            allMessageIds.push(...ids);
+            pageToken = listResp.nextPageToken ?? undefined;
+            if (!pageToken) break;
+          }
+          if (allMessageIds.length >= MAX_MESSAGES) break;
+        }
+
+        if (allMessageIds.length === 0) {
+          return ok("No inbox messages found for the selected senders.");
+        }
+
+        for (let i = 0; i < allMessageIds.length; i += BATCH_MODIFY_LIMIT) {
+          const chunk = allMessageIds.slice(i, i + BATCH_MODIFY_LIMIT);
+          await batchModifyMessages(connection, chunk, {
+            removeLabelIds: ["INBOX"],
+          });
+        }
+
+        const parts = [
+          `Archived ${allMessageIds.length} message(s) via query fallback (scan results had expired).`,
+        ];
+        if (undecodable.length > 0) {
+          parts.push(
+            `${undecodable.length} sender ID(s) could not be decoded and were skipped.`,
+          );
+        }
+        return ok(parts.join(" "));
+      } catch (e) {
+        return err(e instanceof Error ? e.message : String(e));
+      }
+    } else {
       return err(
-        "Scan results have expired (30-minute window). Please re-run the scan to get fresh results.",
+        "The provided sender IDs do not match the scan results. Please re-run the scan.",
       );
     }
-    messageIds = resolved;
   } else if (messageIds?.length) {
     // Batch message_ids path requires surface action confirmation
-    if (!context.triggeredBySurfaceAction) {
+    if (!context.triggeredBySurfaceAction && !context.batchAuthorizedByTask) {
       return err(
-        "This tool requires user confirmation via a surface action. Present results in a selection table with action buttons and wait for the user to click before proceeding.",
+        "This tool requires either a surface action or a scheduled task run with this tool in required_tools. Present results in a selection table with action buttons and wait for the user to click before proceeding.",
       );
     }
   } else if (messageId) {
@@ -133,6 +238,7 @@ export async function run(
       await modifyMessage(connection, messageIds[0], {
         removeLabelIds: ["INBOX"],
       });
+      recordBlocklist(scanId, senderIds);
       return ok("Message archived.");
     }
 
@@ -142,6 +248,7 @@ export async function run(
         removeLabelIds: ["INBOX"],
       });
     }
+    recordBlocklist(scanId, senderIds);
     return ok(`Archived ${messageIds.length} message(s).`);
   } catch (e) {
     return err(e instanceof Error ? e.message : String(e));

package/src/config/bundled-skills/gmail/tools/gmail-outreach-scan.ts

@@ -11,6 +11,11 @@ import type {
 import { storeScanResult } from "./scan-result-store.js";
 import { err, ok } from "./shared.js";
 
+function isRateLimitError(e: unknown): boolean {
+  if (!(e instanceof Error)) return false;
+  return /\b429\b/.test(e.message);
+}
+
 const MAX_MESSAGES_CAP = 5000;
 const MAX_IDS_PER_SENDER = 5000;
 const MAX_SAMPLE_SUBJECTS = 3;
@@ -69,6 +74,8 @@ export async function run(
     const startTime = Date.now();
     const TIME_BUDGET_MS = 90_000;
 
+    let rateLimited = false;
+
     while (allMessageIds.length < maxMessages) {
       if (Date.now() - startTime > TIME_BUDGET_MS) {
         timeBudgetExceeded = true;
@@ -76,12 +83,17 @@ export async function run(
         break;
       }
       const pageSize = Math.min(100, maxMessages - allMessageIds.length);
-      const listResp = await listMessages(
-        connection,
-        query,
-        pageSize,
-        pageToken,
-      );
+      let listResp;
+      try {
+        listResp = await listMessages(connection, query, pageSize, pageToken);
+      } catch (e) {
+        if (isRateLimitError(e)) {
+          rateLimited = true;
+          truncated = true;
+          break;
+        }
+        throw e;
+      }
       const ids = (listResp.messages ?? []).map((m) => m.id);
       if (ids.length === 0) break;
       allMessageIds.push(...ids);
@@ -103,6 +115,17 @@ export async function run(
     }
 
     if (allMessageIds.length === 0) {
+      if (rateLimited) {
+        return ok(
+          JSON.stringify({
+            senders: [],
+            total_scanned: 0,
+            rate_limited: true,
+            truncated: true,
+            note: "Rate limited before any messages could be fetched. Try again later or reduce max_messages.",
+          }),
+        );
+      }
       return ok(
         JSON.stringify({
           senders: [],
@@ -112,7 +135,35 @@ export async function run(
       );
     }
 
-    const messages = (await Promise.all(fetchPromises)).flat();
+    // Settle all fetch promises — collect successes and tolerate 429 failures.
+    const elapsedMs = Date.now() - startTime;
+    const settleDeadlineMs = Math.max(TIME_BUDGET_MS - elapsedMs, 5_000);
+    const deadlineRejection = new Promise<never>((_, reject) =>
+      setTimeout(
+        () => reject(new Error("fetch deadline exceeded")),
+        settleDeadlineMs,
+      ),
+    );
+    const settled = await Promise.allSettled(
+      fetchPromises.map((p) => Promise.race([p, deadlineRejection])),
+    );
+    const messages: GmailMessage[] = [];
+    for (const result of settled) {
+      if (result.status === "fulfilled") {
+        messages.push(...result.value);
+      } else if (isRateLimitError(result.reason)) {
+        rateLimited = true;
+        truncated = true;
+      } else if (
+        result.reason instanceof Error &&
+        result.reason.message === "fetch deadline exceeded"
+      ) {
+        timeBudgetExceeded = true;
+        truncated = true;
+      } else {
+        throw result.reason;
+      }
+    }
 
     // Aggregate all fetched messages by sender
     const senderMap = new Map<string, OutreachSenderAggregation>();
@@ -177,16 +228,91 @@ export async function run(
       }
     }
 
-    // Sort by message count desc, take top N
+    // Sort by message count desc — over-fetch before enrichment, cap after
     const sorted = [...senderMap.values()]
       .sort((a, b) => b.messageCount - a.messageCount)
-      .slice(0, maxSenders);
+      .slice(0, maxSenders * 3);
+
+    // Enrich with prior-reply signal: check if user has ever sent to each sender.
+    // Uses bounded concurrency (batches of 10) and AbortController to cancel
+    // in-flight requests when the time budget expires.
+    const ENRICHMENT_CONCURRENCY = 10;
+    const priorReplyMap = new Map<string, boolean>();
+    if (!rateLimited) {
+      const enrichmentBudgetMs = Math.max(
+        TIME_BUDGET_MS - (Date.now() - startTime),
+        5_000,
+      );
+      const abortController = new AbortController();
+      const budgetTimer = setTimeout(
+        () => abortController.abort(),
+        enrichmentBudgetMs,
+      );
+
+      try {
+        // Process in waves to limit concurrency and stop on budget expiry
+        for (
+          let i = 0;
+          i < sorted.length && !abortController.signal.aborted;
+          i += ENRICHMENT_CONCURRENCY
+        ) {
+          const batch = sorted.slice(i, i + ENRICHMENT_CONCURRENCY);
+          const batchChecks = batch.map(async (s) => {
+            if (abortController.signal.aborted) return;
+            try {
+              const resp = await listMessages(
+                connection,
+                `from:me to:${s.email}`,
+                1,
+              );
+              priorReplyMap.set(s.email, (resp.messages?.length ?? 0) > 0);
+            } catch {
+              // Non-fatal — default to safe direction (assume prior reply exists)
+              priorReplyMap.set(s.email, true);
+            }
+          });
+          await Promise.race([
+            Promise.all(batchChecks),
+            new Promise<void>((resolve) =>
+              abortController.signal.addEventListener(
+                "abort",
+                () => resolve(),
+                {
+                  once: true,
+                },
+              ),
+            ),
+          ]);
+        }
+      } finally {
+        clearTimeout(budgetTimer);
+      }
+
+      // Default any un-enriched senders to safe direction
+      for (const s of sorted) {
+        if (!priorReplyMap.has(s.email)) {
+          priorReplyMap.set(s.email, true);
+        }
+      }
+    } else {
+      // Rate limited — default all to safe direction
+      for (const s of sorted) {
+        priorReplyMap.set(s.email, true);
+      }
+    }
 
-    const senders = sorted.map((s) => ({
+    // Filter out senders with prior replies, then cap to maxSenders.
+    // This is the purpose of over-fetching (maxSenders * 3): enrich more
+    // candidates, discard those with existing replies, then take the top N.
+    const capped = sorted
+      .filter((s) => !priorReplyMap.get(s.email))
+      .slice(0, maxSenders);
+    const senders = capped.map((s) => ({
       id: Buffer.from(s.email).toString("base64url"),
       display_name: s.displayName || s.email.split("@")[0],
       email: s.email,
       message_count: s.messageCount,
+      has_prior_reply: priorReplyMap.get(s.email) ?? true,
       newest_message_id: s.newestMessageId,
       oldest_date: s.oldestDate,
       newest_date: s.newestDate,
@@ -196,7 +322,7 @@ export async function run(
 
     // Store message IDs server-side to keep them out of LLM context
     const scanId = storeScanResult(
-      sorted.map((s) => ({
+      capped.map((s) => ({
         id: Buffer.from(s.email).toString("base64url"),
         messageIds: s.messageIds,
         newestMessageId: s.newestMessageId,
@@ -211,6 +337,7 @@ export async function run(
         total_scanned: allMessageIds.length,
         ...(truncated ? { truncated: true } : {}),
         ...(timeBudgetExceeded ? { time_budget_exceeded: true } : {}),
+        ...(rateLimited ? { rate_limited: true } : {}),
         note: "Scanned inbox for senders without List-Unsubscribe headers (potential cold outreach). Use gmail_archive and gmail_filters for cleanup.",
       }),
     );

package/src/config/bundled-skills/gmail/tools/gmail-preferences-tool.ts

@@ -0,0 +1,59 @@
+import type {
+  ToolContext,
+  ToolExecutionResult,
+} from "../../../../tools/types.js";
+import {
+  addToBlocklist,
+  addToSafelist,
+  loadPreferences,
+  removeFromBlocklist,
+  removeFromSafelist,
+} from "./gmail-preferences.js";
+import { err, ok } from "./shared.js";
+
+export async function run(
+  input: Record<string, unknown>,
+  _context: ToolContext,
+): Promise<ToolExecutionResult> {
+  const action = input.action as string;
+  const emails = input.emails as string[] | undefined;
+
+  switch (action) {
+    case "list": {
+      const prefs = loadPreferences();
+      return ok(
+        JSON.stringify({
+          blocklist_count: prefs.blocklist.length,
+          safelist_count: prefs.safelist.length,
+          blocklist: prefs.blocklist,
+          safelist: prefs.safelist,
+        }),
+      );
+    }
+    case "add_blocklist": {
+      if (!emails?.length) return err("emails is required for add_blocklist");
+      addToBlocklist(emails);
+      return ok(`Added ${emails.length} sender(s) to blocklist.`);
+    }
+    case "add_safelist": {
+      if (!emails?.length) return err("emails is required for add_safelist");
+      addToSafelist(emails);
+      return ok(`Added ${emails.length} sender(s) to safelist.`);
+    }
+    case "remove_blocklist": {
+      if (!emails?.length)
+        return err("emails is required for remove_blocklist");
+      removeFromBlocklist(emails);
+      return ok(`Removed ${emails.length} sender(s) from blocklist.`);
+    }
+    case "remove_safelist": {
+      if (!emails?.length) return err("emails is required for remove_safelist");
+      removeFromSafelist(emails);
+      return ok(`Removed ${emails.length} sender(s) from safelist.`);
+    }
+    default:
+      return err(
+        `Unknown action "${action}". Use list, add_blocklist, add_safelist, remove_blocklist, or remove_safelist.`,
+      );
+  }
+}

package/src/config/bundled-skills/gmail/tools/gmail-preferences.ts

@@ -0,0 +1,82 @@
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+
+import { getWorkspaceDir } from "../../../../util/platform.js";
+
+interface GmailPreferences {
+  /** Sender emails archived in previous sessions — auto-archive candidates. */
+  blocklist: string[];
+  /** Sender emails the user explicitly kept (deselected) — exclude from future tables. */
+  safelist: string[];
+}
+
+const PREFS_FILENAME = "gmail-preferences.json";
+
+function getPrefsPath(): string {
+  return join(getWorkspaceDir(), "data", PREFS_FILENAME);
+}
+
+export function loadPreferences(): GmailPreferences {
+  try {
+    const raw = readFileSync(getPrefsPath(), "utf-8");
+    const parsed = JSON.parse(raw) as Partial<GmailPreferences>;
+    return {
+      blocklist: Array.isArray(parsed.blocklist) ? parsed.blocklist : [],
+      safelist: Array.isArray(parsed.safelist) ? parsed.safelist : [],
+    };
+  } catch {
+    return { blocklist: [], safelist: [] };
+  }
+}
+
+function savePreferences(prefs: GmailPreferences): void {
+  const path = getPrefsPath();
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, JSON.stringify(prefs, null, 2));
+}
+
+/** Add sender emails to the blocklist (deduplicated). */
+export function addToBlocklist(emails: string[]): void {
+  const prefs = loadPreferences();
+  const existing = new Set(prefs.blocklist);
+  for (const email of emails) {
+    const normalized = email.toLowerCase();
+    existing.add(normalized);
+    // If a sender is blocklisted, remove them from safelist
+    const safeIdx = prefs.safelist.indexOf(normalized);
+    if (safeIdx !== -1) prefs.safelist.splice(safeIdx, 1);
+  }
+  prefs.blocklist = [...existing];
+  savePreferences(prefs);
+}
+
+/** Add sender emails to the safelist (deduplicated). */
+export function addToSafelist(emails: string[]): void {
+  const prefs = loadPreferences();
+  const existing = new Set(prefs.safelist);
+  for (const email of emails) {
+    const normalized = email.toLowerCase();
+    existing.add(normalized);
+    // If a sender is safelisted, remove them from blocklist
+    const blockIdx = prefs.blocklist.indexOf(normalized);
+    if (blockIdx !== -1) prefs.blocklist.splice(blockIdx, 1);
+  }
+  prefs.safelist = [...existing];
+  savePreferences(prefs);
+}
+
+/** Remove sender emails from the blocklist. */
+export function removeFromBlocklist(emails: string[]): void {
+  const prefs = loadPreferences();
+  const toRemove = new Set(emails.map((e) => e.toLowerCase()));
+  prefs.blocklist = prefs.blocklist.filter((e) => !toRemove.has(e));
+  savePreferences(prefs);
+}
+
+/** Remove sender emails from the safelist. */
+export function removeFromSafelist(emails: string[]): void {
+  const prefs = loadPreferences();
+  const toRemove = new Set(emails.map((e) => e.toLowerCase()));
+  prefs.safelist = prefs.safelist.filter((e) => !toRemove.has(e));
+  savePreferences(prefs);
+}