@vellumai/assistant 0.6.4 → 0.6.6

package/src/config/bundled-skills/gmail/tools/gmail-send-draft.ts

@@ -1,26 +0,0 @@
-import { sendDraft } from "../../../../messaging/providers/gmail/client.js";
-import { resolveOAuthConnection } from "../../../../oauth/connection-resolver.js";
-import type {
-  ToolContext,
-  ToolExecutionResult,
-} from "../../../../tools/types.js";
-import { err, ok } from "./shared.js";
-
-export async function run(
-  input: Record<string, unknown>,
-  _context: ToolContext,
-): Promise<ToolExecutionResult> {
-  const account = input.account as string | undefined;
-  const draftId = input.draft_id as string;
-  if (!draftId) return err("draft_id is required.");
-
-  try {
-    const connection = await resolveOAuthConnection("google", {
-      account,
-    });
-    const msg = await sendDraft(connection, draftId);
-    return ok(`Draft sent (Message ID: ${msg.id}).`);
-  } catch (e) {
-    return err(e instanceof Error ? e.message : String(e));
-  }
-}

package/src/config/bundled-skills/gmail/tools/gmail-sender-digest.ts

@@ -1,347 +0,0 @@
-import {
-  batchGetMessages,
-  listMessages,
-} from "../../../../messaging/providers/gmail/client.js";
-import type { GmailMessage } from "../../../../messaging/providers/gmail/types.js";
-import { resolveOAuthConnection } from "../../../../oauth/connection-resolver.js";
-import type {
-  ToolContext,
-  ToolExecutionResult,
-} from "../../../../tools/types.js";
-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);
-}
-
-function isAbortError(e: unknown): boolean {
-  if (e instanceof DOMException && e.name === "AbortError") return true;
-  if (e instanceof Error && e.message === "fetch deadline exceeded") return true;
-  // AbortSignal.reason propagated through promise chains
-  if (
-    e instanceof Error &&
-    "cause" in e &&
-    e.cause instanceof Error &&
-    e.cause.message === "fetch deadline exceeded"
-  )
-    return true;
-  return false;
-}
-
-const MAX_MESSAGES_CAP = 5000;
-const MAX_IDS_PER_SENDER = 5000;
-const MAX_SAMPLE_SUBJECTS = 3;
-const MAX_SENDERS_CAP = 75;
-const MAX_SUBJECT_LENGTH = 80;
-const MAX_RESULT_BYTES = 24_000;
-
-interface SenderAggregation {
-  displayName: string;
-  email: string;
-  messageCount: number;
-  hasUnsubscribe: boolean;
-  newestMessageId: string;
-  newestUnsubscribableMessageId: string | null;
-  newestUnsubscribableEpoch: number;
-  oldestDate: string;
-  newestDate: string;
-  messageIds: string[];
-  hasMore: boolean;
-  sampleSubjects: string[];
-}
-
-/** Parse "Display Name <email@example.com>" into parts. */
-function parseFrom(from: string): { displayName: string; email: string } {
-  const match = from.match(/^(.+?)\s*<([^>]+)>$/);
-  if (match) {
-    return {
-      displayName: match[1].replace(/^["']|["']$/g, "").trim(),
-      email: match[2].toLowerCase(),
-    };
-  }
-  // Bare email address
-  const bare = from.trim().toLowerCase();
-  return { displayName: "", email: bare };
-}
-
-export async function run(
-  input: Record<string, unknown>,
-  _context: ToolContext,
-): Promise<ToolExecutionResult> {
-  const account = input.account as string | undefined;
-  const query =
-    (input.query as string) ?? "in:inbox category:promotions newer_than:90d";
-  const maxMessages = Math.min(
-    (input.max_messages as number) ?? 2000,
-    MAX_MESSAGES_CAP,
-  );
-  const maxSenders = Math.min(
-    (input.max_senders as number) ?? 50,
-    MAX_SENDERS_CAP,
-  );
-  const inputPageToken = input.page_token as string | undefined;
-
-  try {
-    const connection = await resolveOAuthConnection("google", {
-      account,
-    });
-    // Pipeline: fire metadata fetches for each page of IDs as they arrive,
-    // overlapping fetch latency with pagination latency
-    const allMessageIds: string[] = [];
-    const fetchPromises: Promise<GmailMessage[]>[] = [];
-    const fetchAbort = new AbortController();
-    let pageToken: string | undefined = inputPageToken;
-    let truncated = false;
-    let timeBudgetExceeded = false;
-    const metadataHeaders = ["From", "List-Unsubscribe", "Subject", "Date"];
-    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;
-        truncated = true;
-        break;
-      }
-      const pageSize = Math.min(100, maxMessages - allMessageIds.length);
-      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);
-      fetchPromises.push(
-        batchGetMessages(
-          connection,
-          ids,
-          "metadata",
-          metadataHeaders,
-          "id,internalDate,payload/headers",
-          fetchAbort.signal,
-        ),
-      );
-      pageToken = listResp.nextPageToken ?? undefined;
-      if (!pageToken) break;
-    }
-
-    // If we stopped because we hit the cap but there were still more pages, flag truncation
-    if (allMessageIds.length >= maxMessages && pageToken) {
-      truncated = true;
-    }
-
-    if (allMessageIds.length === 0) {
-      if (rateLimited) {
-        return ok(
-          JSON.stringify({
-            senders: [],
-            total_scanned: 0,
-            rate_limited: true,
-            truncated: true,
-            message:
-              "Rate limited before any messages could be fetched. Try again later or reduce max_messages.",
-          }),
-        );
-      }
-      return ok(
-        JSON.stringify({
-          senders: [],
-          total_scanned: 0,
-          message:
-            "No emails found matching the query. Try broadening the search (e.g. remove category filter or extend date range).",
-        }),
-      );
-    }
-
-    // Settle all fetch promises — collect successes and tolerate 429 failures.
-    // Abort in-flight requests when the deadline fires so they don't continue
-    // consuming API quota in the background.
-    const elapsedMs = Date.now() - startTime;
-    const settleDeadlineMs = Math.max(TIME_BUDGET_MS - elapsedMs, 5_000);
-    const deadlineTimer = setTimeout(() => {
-      fetchAbort.abort(new Error("fetch deadline exceeded"));
-    }, settleDeadlineMs);
-    const settled = await Promise.allSettled(fetchPromises);
-    clearTimeout(deadlineTimer);
-    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 (isAbortError(result.reason)) {
-        timeBudgetExceeded = true;
-        truncated = true;
-      } else {
-        throw result.reason;
-      }
-    }
-
-    // Group by sender email
-    const senderMap = new Map<string, SenderAggregation>();
-
-    for (const msg of messages) {
-      const headers = msg.payload?.headers ?? [];
-      const fromHeader =
-        headers.find((h) => h.name.toLowerCase() === "from")?.value ?? "";
-      const subject =
-        headers.find((h) => h.name.toLowerCase() === "subject")?.value ?? "";
-      const dateStr =
-        headers.find((h) => h.name.toLowerCase() === "date")?.value ?? "";
-      const listUnsub = headers.find(
-        (h) => h.name.toLowerCase() === "list-unsubscribe",
-      )?.value;
-
-      const { displayName, email } = parseFrom(fromHeader);
-      if (!email) continue;
-
-      let agg = senderMap.get(email);
-      if (!agg) {
-        agg = {
-          displayName,
-          email,
-          messageCount: 0,
-          hasUnsubscribe: false,
-          newestMessageId: msg.id,
-          newestUnsubscribableMessageId: null,
-          newestUnsubscribableEpoch: 0,
-          oldestDate: dateStr,
-          newestDate: dateStr,
-          messageIds: [],
-          hasMore: false,
-          sampleSubjects: [],
-        };
-        senderMap.set(email, agg);
-      }
-
-      agg.messageCount++;
-
-      if (listUnsub) agg.hasUnsubscribe = true;
-
-      // Use displayName from earliest message that has one
-      if (!agg.displayName && displayName) agg.displayName = displayName;
-
-      // Track message IDs (cap at MAX_IDS_PER_SENDER)
-      if (agg.messageIds.length < MAX_IDS_PER_SENDER) {
-        agg.messageIds.push(msg.id);
-      } else {
-        agg.hasMore = true;
-      }
-
-      // Track date range - compare using internalDate (epoch ms) for reliability
-      const msgEpoch = msg.internalDate ? Number(msg.internalDate) : 0;
-      const oldestEpoch = agg.oldestDate
-        ? new Date(agg.oldestDate).getTime()
-        : Infinity;
-      const newestEpoch = agg.newestDate
-        ? new Date(agg.newestDate).getTime()
-        : 0;
-
-      if (msgEpoch > 0 && msgEpoch < oldestEpoch) {
-        agg.oldestDate = dateStr || agg.oldestDate;
-      }
-      if (msgEpoch > newestEpoch) {
-        agg.newestDate = dateStr || agg.newestDate;
-        agg.newestMessageId = msg.id;
-      }
-
-      // Track the newest message that actually has List-Unsubscribe so
-      // gmail_unsubscribe() is called with a message that carries the header
-      if (listUnsub && msgEpoch >= agg.newestUnsubscribableEpoch) {
-        agg.newestUnsubscribableMessageId = msg.id;
-        agg.newestUnsubscribableEpoch = msgEpoch;
-      }
-
-      // Collect sample subjects
-      if (subject && agg.sampleSubjects.length < MAX_SAMPLE_SUBJECTS) {
-        agg.sampleSubjects.push(subject);
-      }
-    }
-
-    // Sort by message count descending, take top N
-    const sorted = [...senderMap.values()]
-      .sort((a, b) => b.messageCount - a.messageCount)
-      .slice(0, maxSenders);
-
-    const resultSenders = sorted.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_unsubscribe: s.hasUnsubscribe,
-      // When unsubscribe is available, point to a message that carries the header
-      newest_message_id:
-        s.hasUnsubscribe && s.newestUnsubscribableMessageId
-          ? s.newestUnsubscribableMessageId
-          : s.newestMessageId,
-      oldest_date: s.oldestDate,
-      newest_date: s.newestDate,
-      // Preserve original query filters so follow-up searches stay scoped
-      search_query: `from:${s.email} ${query}`,
-      sample_subjects: s.sampleSubjects.map((subj) =>
-        subj.length > MAX_SUBJECT_LENGTH
-          ? subj.slice(0, MAX_SUBJECT_LENGTH) + "…"
-          : subj,
-      ),
-    }));
-
-    // Trim senders if the serialized result would exceed the byte budget.
-    // Senders are already sorted by message_count desc, so we drop the
-    // least-active ones first.
-    while (resultSenders.length > 1) {
-      const probe = JSON.stringify({ senders: resultSenders });
-      if (probe.length <= MAX_RESULT_BYTES) break;
-      resultSenders.pop();
-    }
-
-    // Build a set of sender IDs that survived the trim so the scan store
-    // only holds entries the LLM can reference.
-    const keptSenderIds = new Set(resultSenders.map((s) => s.id));
-
-    // Store message IDs server-side to keep them out of LLM context
-    const scanId = storeScanResult(
-      sorted
-        .filter((s) =>
-          keptSenderIds.has(Buffer.from(s.email).toString("base64url")),
-        )
-        .map((s) => ({
-          id: Buffer.from(s.email).toString("base64url"),
-          messageIds: s.messageIds,
-          newestMessageId: s.newestMessageId,
-          newestUnsubscribableMessageId: s.newestUnsubscribableMessageId,
-        })),
-    );
-
-    return ok(
-      JSON.stringify({
-        scan_id: scanId,
-        senders: resultSenders,
-        total_scanned: allMessageIds.length,
-        query_used: query,
-        ...(truncated ? { truncated: true } : {}),
-        ...(timeBudgetExceeded ? { time_budget_exceeded: true } : {}),
-        ...(rateLimited ? { rate_limited: true } : {}),
-        note: `message_count reflects emails found per sender within the ${allMessageIds.length} messages scanned. Use scan_id with gmail_archive to archive messages (pass scan_id + sender_ids instead of message_ids).`,
-      }),
-    );
-  } catch (e) {
-    return err(e instanceof Error ? e.message : String(e));
-  }
-}

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

@@ -1,29 +0,0 @@
-import { trashMessage } from "../../../../messaging/providers/gmail/client.js";
-import { resolveOAuthConnection } from "../../../../oauth/connection-resolver.js";
-import type {
-  ToolContext,
-  ToolExecutionResult,
-} from "../../../../tools/types.js";
-import { err, ok } from "./shared.js";
-
-export async function run(
-  input: Record<string, unknown>,
-  _context: ToolContext,
-): Promise<ToolExecutionResult> {
-  const account = input.account as string | undefined;
-  const messageId = input.message_id as string;
-
-  if (!messageId) {
-    return err("message_id is required.");
-  }
-
-  try {
-    const connection = await resolveOAuthConnection("google", {
-      account,
-    });
-    await trashMessage(connection, messageId);
-    return ok("Message moved to trash.");
-  } catch (e) {
-    return err(e instanceof Error ? e.message : String(e));
-  }
-}

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

@@ -1,122 +0,0 @@
-import {
-  getMessage,
-  sendMessage,
-} from "../../../../messaging/providers/gmail/client.js";
-import { resolveOAuthConnection } from "../../../../oauth/connection-resolver.js";
-import {
-  isPrivateOrLocalHost,
-  resolveHostAddresses,
-  resolveRequestAddress,
-} from "../../../../tools/network/url-safety.js";
-import type {
-  ToolContext,
-  ToolExecutionResult,
-} from "../../../../tools/types.js";
-import { err, ok, pinnedHttpsRequest } from "./shared.js";
-
-export async function run(
-  input: Record<string, unknown>,
-  context: ToolContext,
-): Promise<ToolExecutionResult> {
-  const account = input.account as string | undefined;
-  if (!context.triggeredBySurfaceAction && !context.batchAuthorizedByTask) {
-    return err(
-      "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 messageId = input.message_id as string;
-
-  if (!messageId) {
-    return err("message_id is required.");
-  }
-
-  try {
-    const connection = await resolveOAuthConnection("google", {
-      account,
-    });
-    const message = await getMessage(connection, messageId, "metadata", [
-      "List-Unsubscribe",
-      "List-Unsubscribe-Post",
-    ]);
-    const headers = message.payload?.headers ?? [];
-    const unsubHeader = headers.find(
-      (h) => h.name.toLowerCase() === "list-unsubscribe",
-    )?.value;
-
-    if (!unsubHeader) {
-      return err(
-        "No List-Unsubscribe header found. Manual unsubscribe may be required.",
-      );
-    }
-
-    const httpsMatch = unsubHeader.match(/<(https:\/\/[^>]+)>/);
-    const mailtoMatch = unsubHeader.match(/<mailto:([^>]+)>/);
-    const postHeader = headers.find(
-      (h) => h.name.toLowerCase() === "list-unsubscribe-post",
-    )?.value;
-
-    if (httpsMatch) {
-      const url = httpsMatch[1];
-      let parsed: URL;
-      let validatedAddresses: string[];
-      try {
-        parsed = new URL(url);
-        if (parsed.protocol !== "https:") {
-          return err("Unsubscribe URL must use HTTPS.");
-        }
-        if (isPrivateOrLocalHost(parsed.hostname)) {
-          return err("Unsubscribe URL points to a private or local address.");
-        }
-        const { addresses, blockedAddress } = await resolveRequestAddress(
-          parsed.hostname,
-          resolveHostAddresses,
-          false,
-        );
-        if (blockedAddress) {
-          return err("Unsubscribe URL resolves to a private or local address.");
-        }
-        if (addresses.length === 0) {
-          return err("Unable to resolve unsubscribe URL hostname.");
-        }
-        validatedAddresses = addresses;
-      } catch {
-        return err("Invalid unsubscribe URL.");
-      }
-
-      const method = postHeader ? "POST" : "GET";
-      const reqOpts = postHeader
-        ? {
-            method: "POST" as const,
-            headers: { "Content-Type": "application/x-www-form-urlencoded" },
-            body: postHeader,
-          }
-        : undefined;
-
-      let lastStatus = 0;
-      for (const address of validatedAddresses) {
-        try {
-          lastStatus = await pinnedHttpsRequest(parsed, address, reqOpts);
-          if (lastStatus >= 200 && lastStatus < 400) {
-            return ok(`Successfully unsubscribed via HTTPS ${method}.`);
-          }
-        } catch {
-          continue;
-        }
-      }
-      return err(`Unsubscribe request failed: ${lastStatus}`);
-    }
-
-    if (mailtoMatch) {
-      const mailtoAddr = mailtoMatch[1].split("?")[0];
-      await sendMessage(connection, mailtoAddr, "Unsubscribe", "Unsubscribe");
-      return ok(`Unsubscribe email sent to ${mailtoAddr}.`);
-    }
-
-    return err(
-      "No supported unsubscribe method found (requires https: or mailto: URL).",
-    );
-  } catch (e) {
-    return err(e instanceof Error ? e.message : String(e));
-  }
-}

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

@@ -1,67 +0,0 @@
-import {
-  getVacation,
-  updateVacation,
-} from "../../../../messaging/providers/gmail/client.js";
-import type { GmailVacationSettings } from "../../../../messaging/providers/gmail/types.js";
-import { resolveOAuthConnection } from "../../../../oauth/connection-resolver.js";
-import type {
-  ToolContext,
-  ToolExecutionResult,
-} from "../../../../tools/types.js";
-import { err, ok } from "./shared.js";
-
-export async function run(
-  input: Record<string, unknown>,
-  _context: ToolContext,
-): Promise<ToolExecutionResult> {
-  const account = input.account as string | undefined;
-  const action = input.action as string;
-
-  if (!action) {
-    return err("action is required (get, enable, or disable).");
-  }
-
-  try {
-    const connection = await resolveOAuthConnection("google", {
-      account,
-    });
-    switch (action) {
-      case "get": {
-        const settings = await getVacation(connection);
-        return ok(JSON.stringify(settings, null, 2));
-      }
-
-      case "enable": {
-        const message = input.message as string;
-        if (!message)
-          return err("message is required when enabling vacation responder.");
-
-        const settings: GmailVacationSettings = {
-          enableAutoReply: true,
-          responseSubject: (input.subject as string) ?? "Out of Office",
-          responseBodyPlainText: message,
-          restrictToContacts: (input.restrict_to_contacts as boolean) ?? false,
-          restrictToDomain: (input.restrict_to_domain as boolean) ?? false,
-        };
-
-        if (input.start_time) settings.startTime = String(input.start_time);
-        if (input.end_time) settings.endTime = String(input.end_time);
-
-        const updated = await updateVacation(connection, settings);
-        return ok(
-          `Vacation responder enabled.\n${JSON.stringify(updated, null, 2)}`,
-        );
-      }
-
-      case "disable": {
-        await updateVacation(connection, { enableAutoReply: false });
-        return ok("Vacation responder disabled.");
-      }
-
-      default:
-        return err(`Unknown action "${action}". Use get, enable, or disable.`);
-    }
-  } catch (e) {
-    return err(e instanceof Error ? e.message : String(e));
-  }
-}

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

@@ -1,100 +0,0 @@
-import { randomBytes } from "crypto";
-
-interface SenderData {
-  messageIds: string[];
-  newestMessageId: string;
-  newestUnsubscribableMessageId: string | null;
-}
-
-interface ScanEntry {
-  senders: Map<string, SenderData>;
-  createdAt: number;
-}
-
-const MAX_ENTRIES = 16;
-const TTL_MS = 30 * 60_000; // 30 minutes
-
-const _store = new Map<string, ScanEntry>();
-
-/** Store scan results and return a unique scan ID. */
-export function storeScanResult(
-  senders: Array<{
-    id: string;
-    messageIds: string[];
-    newestMessageId: string;
-    newestUnsubscribableMessageId: string | null;
-  }>,
-): string {
-  const scanId = randomBytes(8).toString("hex");
-
-  // LRU eviction: remove oldest if at capacity
-  if (_store.size >= MAX_ENTRIES) {
-    const oldest = _store.keys().next().value;
-    if (oldest !== undefined) _store.delete(oldest);
-  }
-
-  const senderMap = new Map<string, SenderData>();
-  for (const s of senders) {
-    senderMap.set(s.id, {
-      messageIds: s.messageIds,
-      newestMessageId: s.newestMessageId,
-      newestUnsubscribableMessageId: s.newestUnsubscribableMessageId,
-    });
-  }
-
-  _store.set(scanId, { senders: senderMap, createdAt: Date.now() });
-  return scanId;
-}
-
-/** Retrieve message IDs for the given senders from a scan result. */
-export function getSenderMessageIds(
-  scanId: string,
-  senderIds: string[],
-): string[] | null {
-  const entry = _store.get(scanId);
-  if (!entry) return null;
-  if (Date.now() - entry.createdAt > TTL_MS) {
-    _store.delete(scanId);
-    return null;
-  }
-  // LRU: move to end
-  _store.delete(scanId);
-  _store.set(scanId, entry);
-
-  const ids: string[] = [];
-  for (const sid of senderIds) {
-    const data = entry.senders.get(sid);
-    if (data) ids.push(...data.messageIds);
-  }
-  return ids;
-}
-
-/** Retrieve metadata for a single sender from a scan result. */
-export function getSenderMetadata(
-  scanId: string,
-  senderId: string,
-): {
-  newestMessageId: string;
-  newestUnsubscribableMessageId: string | null;
-} | null {
-  const entry = _store.get(scanId);
-  if (!entry) return null;
-  if (Date.now() - entry.createdAt > TTL_MS) {
-    _store.delete(scanId);
-    return null;
-  }
-  const data = entry.senders.get(senderId);
-  if (!data) return null;
-  return {
-    newestMessageId: data.newestMessageId,
-    newestUnsubscribableMessageId: data.newestUnsubscribableMessageId,
-  };
-}
-
-/** Clear the store (for tests). */
-export function clearScanStore(): void {
-  _store.clear();
-}
-
-/** Visible for testing: override TTL check by returning internal store reference. */
-export const _internals = { store: _store, TTL_MS };