@vellumai/assistant 0.5.16 → 0.6.0

package/src/config/bundled-skills/outlook/tools/outlook-draft.ts

@@ -0,0 +1,84 @@
+import {
+  createDraft,
+  createReplyDraft,
+  patchMessage,
+} from "../../../../messaging/providers/outlook/client.js";
+import type { OutlookRecipient } from "../../../../messaging/providers/outlook/types.js";
+import { resolveOAuthConnection } from "../../../../oauth/connection-resolver.js";
+import type {
+  ToolContext,
+  ToolExecutionResult,
+} from "../../../../tools/types.js";
+import { err, ok } from "./shared.js";
+
+function toRecipients(csv: string | undefined): OutlookRecipient[] | undefined {
+  if (!csv) return undefined;
+  return csv
+    .split(",")
+    .map((s) => s.trim())
+    .filter(Boolean)
+    .map((address) => ({ emailAddress: { address } }));
+}
+
+export async function run(
+  input: Record<string, unknown>,
+  _context: ToolContext,
+): Promise<ToolExecutionResult> {
+  const account = input.account as string | undefined;
+  const to = input.to as string;
+  const subject = input.subject as string;
+  const body = input.body as string;
+  const inReplyTo = input.in_reply_to as string | undefined;
+  const cc = input.cc as string | undefined;
+  const bcc = input.bcc as string | undefined;
+
+  if (!to) return err("to is required.");
+  if (!subject) return err("subject is required.");
+  if (!body) return err("body is required.");
+
+  try {
+    const connection = await resolveOAuthConnection("outlook", {
+      account,
+    });
+
+    if (inReplyTo) {
+      // Create a reply draft, then optionally patch recipients
+      const draft = await createReplyDraft(connection, inReplyTo, body);
+
+      const toList = toRecipients(to);
+      const ccList = toRecipients(cc);
+      const bccList = toRecipients(bcc);
+
+      const patch: Record<string, unknown> = {};
+      if (toList) patch.toRecipients = toList;
+      if (ccList) patch.ccRecipients = ccList;
+      if (bccList) patch.bccRecipients = bccList;
+
+      if (Object.keys(patch).length > 0) {
+        await patchMessage(connection, draft.id, patch);
+      }
+
+      return ok(
+        `Draft created (ID: ${draft.id}). It will appear in your Outlook Drafts folder. Tell me to send it when ready.`,
+      );
+    }
+
+    const toRecipientsList = toRecipients(to) ?? [];
+    const ccRecipientsList = toRecipients(cc);
+    const bccRecipientsList = toRecipients(bcc);
+
+    const draft = await createDraft(connection, {
+      subject,
+      body: { contentType: "text", content: body },
+      toRecipients: toRecipientsList,
+      ccRecipients: ccRecipientsList,
+      bccRecipients: bccRecipientsList,
+    });
+
+    return ok(
+      `Draft created (ID: ${draft.id}). It will appear in your Outlook Drafts folder. Tell me to send it when ready.`,
+    );
+  } catch (e) {
+    return err(e instanceof Error ? e.message : String(e));
+  }
+}

package/src/config/bundled-skills/outlook/tools/outlook-follow-up.ts

@@ -0,0 +1,94 @@
+import {
+  listMessages,
+  updateMessageFlag,
+} from "../../../../messaging/providers/outlook/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 action = input.action as string;
+
+  if (!action) {
+    return err("action is required (track, list, untrack, or complete).");
+  }
+
+  try {
+    const connection = await resolveOAuthConnection("outlook", {
+      account,
+    });
+
+    switch (action) {
+      case "track": {
+        const messageId = input.message_id as string;
+        if (!messageId) return err("message_id is required for track action.");
+
+        await updateMessageFlag(connection, messageId, {
+          flagStatus: "flagged",
+        });
+        return ok("Message flagged for follow-up.");
+      }
+
+      case "complete": {
+        const messageId = input.message_id as string;
+        if (!messageId)
+          return err("message_id is required for complete action.");
+
+        await updateMessageFlag(connection, messageId, {
+          flagStatus: "complete",
+        });
+        return ok("Follow-up marked complete.");
+      }
+
+      case "untrack": {
+        const messageId = input.message_id as string;
+        if (!messageId)
+          return err("message_id is required for untrack action.");
+
+        await updateMessageFlag(connection, messageId, {
+          flagStatus: "notFlagged",
+        });
+        return ok("Follow-up flag removed.");
+      }
+
+      case "list": {
+        const resp = await listMessages(connection, {
+          filter: "flag/flagStatus eq 'flagged'",
+          top: 50,
+          select:
+            "id,conversationId,subject,bodyPreview,body,from,toRecipients,receivedDateTime,isRead,hasAttachments,parentFolderId,categories,flag",
+          orderby: "receivedDateTime desc",
+        });
+
+        const messages = resp.value ?? [];
+        if (messages.length === 0) {
+          return ok("No messages are currently flagged for follow-up.");
+        }
+
+        const items = messages.map((m) => ({
+          id: m.id,
+          conversationId: m.conversationId,
+          subject: m.subject,
+          from: m.from?.emailAddress?.address ?? "",
+          date: m.receivedDateTime,
+        }));
+
+        return ok(JSON.stringify(items, null, 2));
+      }
+
+      default:
+        return err(
+          `Unknown action "${action}". Use track, list, untrack, or complete.`,
+        );
+    }
+  } catch (e) {
+    return err(e instanceof Error ? e.message : String(e));
+  }
+}

package/src/config/bundled-skills/outlook/tools/outlook-forward.ts

@@ -0,0 +1,49 @@
+import { createForwardDraft } from "../../../../messaging/providers/outlook/client.js";
+import type { OutlookRecipient } from "../../../../messaging/providers/outlook/types.js";
+import { resolveOAuthConnection } from "../../../../oauth/connection-resolver.js";
+import type {
+  ToolContext,
+  ToolExecutionResult,
+} from "../../../../tools/types.js";
+import { err, ok } from "./shared.js";
+
+function toRecipients(csv: string): OutlookRecipient[] {
+  return csv
+    .split(",")
+    .map((s) => s.trim())
+    .filter(Boolean)
+    .map((address) => ({ emailAddress: { address } }));
+}
+
+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;
+  const to = input.to as string;
+  const comment = input.comment as string | undefined;
+
+  if (!messageId) return err("message_id is required.");
+  if (!to) return err("to is required.");
+
+  try {
+    const connection = await resolveOAuthConnection("outlook", {
+      account,
+    });
+
+    const toRecipientsList = toRecipients(to);
+    const draft = await createForwardDraft(
+      connection,
+      messageId,
+      toRecipientsList,
+      comment,
+    );
+
+    return ok(
+      `Forward draft created (ID: ${draft.id}). Review in Outlook Drafts, then tell me to send it.`,
+    );
+  } catch (e) {
+    return err(e instanceof Error ? e.message : String(e));
+  }
+}

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

@@ -0,0 +1,237 @@
+import {
+  batchGetMessages,
+  listMessages,
+} from "../../../../messaging/providers/outlook/client.js";
+import type { OutlookMessage } from "../../../../messaging/providers/outlook/types.js";
+import { resolveOAuthConnection } from "../../../../oauth/connection-resolver.js";
+import type {
+  ToolContext,
+  ToolExecutionResult,
+} from "../../../../tools/types.js";
+import { storeScanResult } from "../../gmail/tools/scan-result-store.js";
+import { err, ok } from "./shared.js";
+
+const MAX_MESSAGES_CAP = 5000;
+const MAX_IDS_PER_SENDER = 5000;
+const MAX_SAMPLE_SUBJECTS = 3;
+
+interface OutreachSenderAggregation {
+  displayName: string;
+  email: string;
+  messageCount: number;
+  newestMessageId: string;
+  oldestDate: string;
+  newestDate: string;
+  messageIds: string[];
+  hasMore: boolean;
+  sampleSubjects: string[];
+}
+
+/** Parse a time range string like "90d" or "30d" into milliseconds. */
+function parseTimeRange(timeRange: string): number {
+  const match = timeRange.match(/^(\d+)([dhm])$/);
+  if (!match) return 90 * 24 * 60 * 60 * 1000; // default 90 days
+  const value = parseInt(match[1], 10);
+  switch (match[2]) {
+    case "d":
+      return value * 24 * 60 * 60 * 1000;
+    case "h":
+      return value * 60 * 60 * 1000;
+    case "m":
+      return value * 60 * 1000;
+    default:
+      return 90 * 24 * 60 * 60 * 1000;
+  }
+}
+
+export async function run(
+  input: Record<string, unknown>,
+  _context: ToolContext,
+): Promise<ToolExecutionResult> {
+  const account = input.account as string | undefined;
+  const maxSenders = (input.max_senders as number) ?? 30;
+  const timeRange = (input.time_range as string) ?? "90d";
+
+  try {
+    const connection = await resolveOAuthConnection("outlook", {
+      account,
+    });
+
+    // Build OData filter: inbox messages from the specified time range
+    const sinceDate = new Date(
+      Date.now() - parseTimeRange(timeRange),
+    ).toISOString();
+    const dateFilter = `receivedDateTime ge ${sinceDate}`;
+
+    const allMessageIds: string[] = [];
+    const fetchPromises: Promise<OutlookMessage[]>[] = [];
+    let skip = 0;
+    let truncated = false;
+    let timeBudgetExceeded = false;
+    const startTime = Date.now();
+    const TIME_BUDGET_MS = 90_000;
+
+    // Paginate through messages
+    while (allMessageIds.length < MAX_MESSAGES_CAP) {
+      if (Date.now() - startTime > TIME_BUDGET_MS) {
+        timeBudgetExceeded = true;
+        truncated = true;
+        break;
+      }
+      const pageSize = Math.min(100, MAX_MESSAGES_CAP - allMessageIds.length);
+
+      const listResp = await listMessages(connection, {
+        top: pageSize,
+        skip,
+        filter: dateFilter,
+        orderby: "receivedDateTime desc",
+        select: "id,from,receivedDateTime,subject",
+      });
+
+      const messages = listResp.value ?? [];
+      if (messages.length === 0) break;
+
+      const ids = messages.map((m) => m.id);
+      allMessageIds.push(...ids);
+
+      // Fetch internet message headers to check for List-Unsubscribe
+      fetchPromises.push(
+        batchGetMessages(
+          connection,
+          ids,
+          "id,from,receivedDateTime,subject,internetMessageHeaders",
+        ),
+      );
+
+      skip += messages.length;
+      if (messages.length < pageSize) break;
+    }
+
+    if (allMessageIds.length >= MAX_MESSAGES_CAP) {
+      truncated = true;
+    }
+
+    if (allMessageIds.length === 0) {
+      return ok(
+        JSON.stringify({
+          senders: [],
+          total_scanned: 0,
+          note: "No emails found matching the query.",
+        }),
+      );
+    }
+
+    const fetchedMessages = (await Promise.all(fetchPromises)).flat();
+
+    // First pass: track which senders have ANY messages with List-Unsubscribe
+    const sendersWithUnsubscribe = new Set<string>();
+    for (const msg of fetchedMessages) {
+      const fromEmail = msg.from?.emailAddress?.address?.toLowerCase();
+      if (!fromEmail) continue;
+      const hasUnsub = msg.internetMessageHeaders?.some(
+        (h) => h.name.toLowerCase() === "list-unsubscribe",
+      );
+      if (hasUnsub) sendersWithUnsubscribe.add(fromEmail);
+    }
+
+    // Second pass: aggregate only senders WITHOUT List-Unsubscribe
+    const senderMap = new Map<string, OutreachSenderAggregation>();
+
+    for (const msg of fetchedMessages) {
+      const fromEmail = msg.from?.emailAddress?.address?.toLowerCase();
+      const fromName = msg.from?.emailAddress?.name ?? "";
+      const subject = msg.subject ?? "";
+      const dateStr = msg.receivedDateTime ?? "";
+
+      if (!fromEmail) continue;
+      // Skip senders that have any messages with List-Unsubscribe
+      if (sendersWithUnsubscribe.has(fromEmail)) continue;
+
+      let agg = senderMap.get(fromEmail);
+      if (!agg) {
+        agg = {
+          displayName: fromName,
+          email: fromEmail,
+          messageCount: 0,
+          newestMessageId: msg.id,
+          oldestDate: dateStr,
+          newestDate: dateStr,
+          messageIds: [],
+          hasMore: false,
+          sampleSubjects: [],
+        };
+        senderMap.set(fromEmail, agg);
+      }
+
+      agg.messageCount++;
+
+      if (!agg.displayName && fromName) agg.displayName = fromName;
+
+      if (agg.messageIds.length < MAX_IDS_PER_SENDER) {
+        agg.messageIds.push(msg.id);
+      } else {
+        agg.hasMore = true;
+      }
+
+      // Track date range
+      const msgEpoch = dateStr ? new Date(dateStr).getTime() : 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;
+      }
+
+      if (subject && agg.sampleSubjects.length < MAX_SAMPLE_SUBJECTS) {
+        agg.sampleSubjects.push(subject);
+      }
+    }
+
+    // Sort by message count desc, take top N
+    const sorted = [...senderMap.values()]
+      .sort((a, b) => b.messageCount - a.messageCount)
+      .slice(0, maxSenders);
+
+    const senders = 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,
+      newest_message_id: s.newestMessageId,
+      oldest_date: s.oldestDate,
+      newest_date: s.newestDate,
+      sample_subjects: s.sampleSubjects,
+    }));
+
+    // Store message IDs server-side to keep them out of LLM context
+    const scanId = storeScanResult(
+      sorted.map((s) => ({
+        id: Buffer.from(s.email).toString("base64url"),
+        messageIds: s.messageIds,
+        newestMessageId: s.newestMessageId,
+        newestUnsubscribableMessageId: null,
+      })),
+    );
+
+    return ok(
+      JSON.stringify({
+        scan_id: scanId,
+        senders,
+        total_scanned: allMessageIds.length,
+        ...(truncated ? { truncated: true } : {}),
+        ...(timeBudgetExceeded ? { time_budget_exceeded: true } : {}),
+        note: "Scanned inbox for senders without List-Unsubscribe headers (potential cold outreach). Use outlook_archive and outlook_mail_rules for cleanup.",
+      }),
+    );
+  } catch (e) {
+    return err(e instanceof Error ? e.message : String(e));
+  }
+}

package/src/config/bundled-skills/outlook/tools/outlook-rules.ts

@@ -0,0 +1,161 @@
+import {
+  createMailRule,
+  deleteMailRule,
+  listMailRules,
+} from "../../../../messaging/providers/outlook/client.js";
+import type {
+  OutlookMessageRuleActions,
+  OutlookMessageRulePredicates,
+} from "../../../../messaging/providers/outlook/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 (list, create, or delete).");
+  }
+
+  try {
+    const connection = await resolveOAuthConnection("outlook", {
+      account,
+    });
+    switch (action) {
+      case "list": {
+        const resp = await listMailRules(connection);
+        const rules = resp.value ?? [];
+        if (rules.length === 0) {
+          return ok("No inbox rules configured.");
+        }
+        const summary = rules.map((r) => ({
+          id: r.id,
+          displayName: r.displayName,
+          isEnabled: r.isEnabled,
+          conditions: summarizeConditions(r.conditions),
+          actions: summarizeActions(r.actions),
+        }));
+        return ok(JSON.stringify(summary, null, 2));
+      }
+
+      case "create": {
+        const displayName = input.display_name as string;
+        if (!displayName)
+          return err("display_name is required for create action.");
+
+        const conditions: OutlookMessageRulePredicates = {};
+        if (input.from_contains)
+          conditions.senderContains = Array.isArray(input.from_contains)
+            ? (input.from_contains as string[])
+            : [input.from_contains as string];
+        if (input.subject_contains)
+          conditions.subjectContains = Array.isArray(input.subject_contains)
+            ? (input.subject_contains as string[])
+            : [input.subject_contains as string];
+        if (input.body_contains)
+          conditions.bodyContains = Array.isArray(input.body_contains)
+            ? (input.body_contains as string[])
+            : [input.body_contains as string];
+        if (input.has_attachment !== undefined)
+          conditions.hasAttachments = input.has_attachment as boolean;
+        if (input.importance)
+          conditions.importance = input.importance as "low" | "normal" | "high";
+
+        if (Object.keys(conditions).length === 0) {
+          return err(
+            "At least one condition is required (from_contains, subject_contains, body_contains, has_attachment, or importance).",
+          );
+        }
+
+        const actions: OutlookMessageRuleActions = {};
+        if (input.move_to_folder)
+          actions.moveToFolder = input.move_to_folder as string;
+        if (input.delete !== undefined)
+          actions.delete = input.delete as boolean;
+        if (input.mark_as_read !== undefined)
+          actions.markAsRead = input.mark_as_read as boolean;
+        if (input.mark_importance)
+          actions.markImportance = input.mark_importance as
+            | "low"
+            | "normal"
+            | "high";
+        if (input.forward_to) {
+          const emails = Array.isArray(input.forward_to)
+            ? (input.forward_to as string[])
+            : [input.forward_to as string];
+          actions.forwardTo = emails.map((addr) => ({
+            emailAddress: { address: addr },
+          }));
+        }
+        if (input.stop_processing !== undefined)
+          actions.stopProcessingRules = input.stop_processing as boolean;
+
+        const rule = await createMailRule(connection, {
+          displayName,
+          sequence: (input.sequence as number) ?? 1,
+          isEnabled: true,
+          conditions,
+          actions,
+        });
+        return ok(`Rule created (ID: ${rule.id}).`);
+      }
+
+      case "delete": {
+        const ruleId = input.rule_id as string;
+        if (!ruleId) return err("rule_id is required for delete action.");
+
+        await deleteMailRule(connection, ruleId);
+        return ok("Rule deleted.");
+      }
+
+      default:
+        return err(`Unknown action "${action}". Use list, create, or delete.`);
+    }
+  } catch (e) {
+    return err(e instanceof Error ? e.message : String(e));
+  }
+}
+
+function summarizeConditions(
+  c: OutlookMessageRulePredicates | undefined,
+): string {
+  if (!c) return "none";
+  const parts: string[] = [];
+  if (c.senderContains?.length)
+    parts.push(`sender contains: ${c.senderContains.join(", ")}`);
+  if (c.subjectContains?.length)
+    parts.push(`subject contains: ${c.subjectContains.join(", ")}`);
+  if (c.bodyContains?.length)
+    parts.push(`body contains: ${c.bodyContains.join(", ")}`);
+  if (c.fromAddresses?.length)
+    parts.push(
+      `from: ${c.fromAddresses.map((a) => a.emailAddress.address).join(", ")}`,
+    );
+  if (c.hasAttachments !== undefined)
+    parts.push(`has attachments: ${c.hasAttachments}`);
+  if (c.importance) parts.push(`importance: ${c.importance}`);
+  return parts.length > 0 ? parts.join("; ") : "none";
+}
+
+function summarizeActions(c: OutlookMessageRuleActions | undefined): string {
+  if (!c) return "none";
+  const parts: string[] = [];
+  if (c.moveToFolder) parts.push(`move to folder: ${c.moveToFolder}`);
+  if (c.delete) parts.push("delete");
+  if (c.markAsRead) parts.push("mark as read");
+  if (c.markImportance) parts.push(`mark importance: ${c.markImportance}`);
+  if (c.forwardTo?.length)
+    parts.push(
+      `forward to: ${c.forwardTo.map((r) => r.emailAddress.address).join(", ")}`,
+    );
+  if (c.stopProcessingRules) parts.push("stop processing rules");
+  return parts.length > 0 ? parts.join("; ") : "none";
+}

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

@@ -0,0 +1,32 @@
+import { sendDraft } from "../../../../messaging/providers/outlook/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.");
+
+  if (!context.triggeredBySurfaceAction) {
+    return err(
+      "This tool requires user confirmation via a surface action. Present the draft details with a send button and wait for the user to click before proceeding.",
+    );
+  }
+
+  try {
+    const connection = await resolveOAuthConnection("outlook", {
+      account,
+    });
+    await sendDraft(connection, draftId);
+    return ok("Draft sent.");
+  } catch (e) {
+    return err(e instanceof Error ? e.message : String(e));
+  }
+}