@vellumai/assistant 0.5.15 → 0.6.0

package/src/__tests__/outlook-declutter-tools.test.ts

@@ -0,0 +1,585 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import type { OutlookMessage } from "../messaging/providers/outlook/types.js";
+
+// ── Mocks ─────────────────────────────────────────────────────────────────────
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    ui: {},
+    memory: {},
+  }),
+}));
+
+const mockListMessages = mock(
+  (): Promise<any> => Promise.resolve({ value: [] as OutlookMessage[] }),
+);
+const mockBatchGetMessages = mock(
+  (): Promise<any> => Promise.resolve([] as OutlookMessage[]),
+);
+
+mock.module("../messaging/providers/outlook/client.js", () => ({
+  listMessages: mockListMessages,
+  batchGetMessages: mockBatchGetMessages,
+}));
+
+const mockResolveOAuthConnection = mock(() =>
+  Promise.resolve({ request: () => Promise.resolve({}) }),
+);
+
+mock.module("../oauth/connection-resolver.js", () => ({
+  resolveOAuthConnection: mockResolveOAuthConnection,
+}));
+
+import {
+  clearScanStore,
+  getSenderMessageIds,
+} from "../config/bundled-skills/gmail/tools/scan-result-store.js";
+import { run as runOutreachScan } from "../config/bundled-skills/outlook/tools/outlook-outreach-scan.js";
+import { run as runSenderDigest } from "../config/bundled-skills/outlook/tools/outlook-sender-digest.js";
+import type { ToolContext } from "../tools/types.js";
+
+const fakeContext = {} as ToolContext;
+
+/** Helper to build an OutlookMessage with optional internet headers. */
+function makeMessage(
+  id: string,
+  fromEmail: string,
+  fromName: string,
+  subject: string,
+  receivedDateTime: string,
+  headers?: Array<{ name: string; value: string }>,
+): OutlookMessage {
+  return {
+    id,
+    conversationId: `conv-${id}`,
+    subject,
+    bodyPreview: "",
+    body: { contentType: "text", content: "" },
+    from: {
+      emailAddress: { address: fromEmail, name: fromName },
+    },
+    toRecipients: [],
+    ccRecipients: [],
+    receivedDateTime,
+    isRead: true,
+    hasAttachments: false,
+    parentFolderId: "inbox",
+    categories: [],
+    flag: { flagStatus: "notFlagged" },
+    internetMessageHeaders: headers,
+  };
+}
+
+beforeEach(() => {
+  mockListMessages.mockReset();
+  mockBatchGetMessages.mockReset();
+  mockResolveOAuthConnection.mockReset();
+  mockResolveOAuthConnection.mockImplementation(() =>
+    Promise.resolve({ request: () => Promise.resolve({}) } as any),
+  );
+  clearScanStore();
+});
+
+// ── outlook_sender_digest ──────────────────────────────────────────────────────
+
+describe("outlook_sender_digest", () => {
+  test("groups messages by sender and detects unsubscribe headers", async () => {
+    const msgs: OutlookMessage[] = [
+      makeMessage(
+        "m1",
+        "news@co.com",
+        "News Co",
+        "Newsletter #1",
+        "2025-01-15T10:00:00Z",
+        [{ name: "List-Unsubscribe", value: "<mailto:unsub@co.com>" }],
+      ),
+      makeMessage(
+        "m2",
+        "news@co.com",
+        "News Co",
+        "Newsletter #2",
+        "2025-01-20T10:00:00Z",
+        [{ name: "List-Unsubscribe", value: "<mailto:unsub@co.com>" }],
+      ),
+      makeMessage(
+        "m3",
+        "alice@example.com",
+        "Alice",
+        "Hello",
+        "2025-01-18T10:00:00Z",
+      ),
+    ];
+
+    mockListMessages.mockImplementationOnce(() =>
+      Promise.resolve({
+        value: msgs.map((m) => ({
+          id: m.id,
+          from: m.from,
+          receivedDateTime: m.receivedDateTime,
+          hasAttachments: false,
+          subject: m.subject,
+        })),
+      }),
+    );
+    mockBatchGetMessages.mockImplementationOnce(() => Promise.resolve(msgs));
+
+    const result = await runSenderDigest({}, fakeContext);
+    expect(result.isError).toBe(false);
+
+    const data = JSON.parse(result.content);
+    expect(data.scan_id).toBeDefined();
+    expect(data.total_scanned).toBe(3);
+    expect(data.senders).toHaveLength(2);
+
+    // news@co.com should be first (2 messages)
+    const newsSender = data.senders[0];
+    expect(newsSender.email).toBe("news@co.com");
+    expect(newsSender.message_count).toBe(2);
+    expect(newsSender.has_unsubscribe).toBe(true);
+    expect(newsSender.sample_subjects).toContain("Newsletter #1");
+
+    // alice@example.com should be second (1 message)
+    const aliceSender = data.senders[1];
+    expect(aliceSender.email).toBe("alice@example.com");
+    expect(aliceSender.message_count).toBe(1);
+    expect(aliceSender.has_unsubscribe).toBe(false);
+  });
+
+  test("returns empty results when no messages found", async () => {
+    mockListMessages.mockImplementationOnce(() =>
+      Promise.resolve({ value: [] }),
+    );
+
+    const result = await runSenderDigest({}, fakeContext);
+    expect(result.isError).toBe(false);
+
+    const data = JSON.parse(result.content);
+    expect(data.senders).toHaveLength(0);
+    expect(data.total_scanned).toBe(0);
+  });
+
+  test("stores scan result for subsequent retrieval", async () => {
+    const msgs: OutlookMessage[] = [
+      makeMessage(
+        "m1",
+        "sender@test.com",
+        "Sender",
+        "Sub1",
+        "2025-01-15T10:00:00Z",
+      ),
+      makeMessage(
+        "m2",
+        "sender@test.com",
+        "Sender",
+        "Sub2",
+        "2025-01-16T10:00:00Z",
+      ),
+    ];
+
+    mockListMessages.mockImplementationOnce(() =>
+      Promise.resolve({
+        value: msgs.map((m) => ({
+          id: m.id,
+          from: m.from,
+          receivedDateTime: m.receivedDateTime,
+          hasAttachments: false,
+          subject: m.subject,
+        })),
+      }),
+    );
+    mockBatchGetMessages.mockImplementationOnce(() => Promise.resolve(msgs));
+
+    const result = await runSenderDigest({}, fakeContext);
+    const data = JSON.parse(result.content);
+    const scanId = data.scan_id;
+    const senderId = data.senders[0].id;
+
+    // Verify we can retrieve message IDs from the scan store
+    const messageIds = getSenderMessageIds(scanId, [senderId]);
+    expect(messageIds).not.toBeNull();
+    expect(messageIds).toContain("m1");
+    expect(messageIds).toContain("m2");
+  });
+
+  test("paginates through multiple pages of messages", async () => {
+    const page1 = Array.from({ length: 100 }, (_, i) =>
+      makeMessage(
+        `p1-${i}`,
+        `sender${i % 5}@test.com`,
+        `Sender ${i % 5}`,
+        `Subject ${i}`,
+        `2025-01-${String(15 + (i % 10)).padStart(2, "0")}T10:00:00Z`,
+      ),
+    );
+    const page2 = Array.from({ length: 50 }, (_, i) =>
+      makeMessage(
+        `p2-${i}`,
+        `sender${i % 3}@test.com`,
+        `Sender ${i % 3}`,
+        `Subject ${100 + i}`,
+        `2025-01-${String(15 + (i % 10)).padStart(2, "0")}T10:00:00Z`,
+      ),
+    );
+
+    let callCount = 0;
+    mockListMessages.mockImplementation(() => {
+      callCount++;
+      if (callCount === 1) {
+        return Promise.resolve({
+          value: page1.map((m) => ({
+            id: m.id,
+            from: m.from,
+            receivedDateTime: m.receivedDateTime,
+            hasAttachments: false,
+            subject: m.subject,
+          })),
+        });
+      }
+      return Promise.resolve({
+        value: page2.map((m) => ({
+          id: m.id,
+          from: m.from,
+          receivedDateTime: m.receivedDateTime,
+          hasAttachments: false,
+          subject: m.subject,
+        })),
+      });
+    });
+
+    let batchCallCount = 0;
+    mockBatchGetMessages.mockImplementation(() => {
+      batchCallCount++;
+      return Promise.resolve(batchCallCount === 1 ? page1 : page2);
+    });
+
+    const result = await runSenderDigest({}, fakeContext);
+    expect(result.isError).toBe(false);
+
+    const data = JSON.parse(result.content);
+    expect(data.total_scanned).toBe(150);
+    expect(data.senders.length).toBeGreaterThan(0);
+  });
+
+  test("respects max_senders parameter", async () => {
+    const msgs: OutlookMessage[] = [
+      makeMessage("m1", "a@test.com", "A", "Sub1", "2025-01-15T10:00:00Z"),
+      makeMessage("m2", "b@test.com", "B", "Sub2", "2025-01-16T10:00:00Z"),
+      makeMessage("m3", "c@test.com", "C", "Sub3", "2025-01-17T10:00:00Z"),
+    ];
+
+    mockListMessages.mockImplementationOnce(() =>
+      Promise.resolve({
+        value: msgs.map((m) => ({
+          id: m.id,
+          from: m.from,
+          receivedDateTime: m.receivedDateTime,
+          hasAttachments: false,
+          subject: m.subject,
+        })),
+      }),
+    );
+    mockBatchGetMessages.mockImplementationOnce(() => Promise.resolve(msgs));
+
+    const result = await runSenderDigest({ max_senders: 2 }, fakeContext);
+    expect(result.isError).toBe(false);
+
+    const data = JSON.parse(result.content);
+    expect(data.senders).toHaveLength(2);
+  });
+
+  test("sender IDs are base64url-encoded email addresses", async () => {
+    const msgs: OutlookMessage[] = [
+      makeMessage(
+        "m1",
+        "test@example.com",
+        "Test",
+        "Sub1",
+        "2025-01-15T10:00:00Z",
+      ),
+    ];
+
+    mockListMessages.mockImplementationOnce(() =>
+      Promise.resolve({
+        value: msgs.map((m) => ({
+          id: m.id,
+          from: m.from,
+          receivedDateTime: m.receivedDateTime,
+          hasAttachments: false,
+          subject: m.subject,
+        })),
+      }),
+    );
+    mockBatchGetMessages.mockImplementationOnce(() => Promise.resolve(msgs));
+
+    const result = await runSenderDigest({}, fakeContext);
+    const data = JSON.parse(result.content);
+
+    const expectedId = Buffer.from("test@example.com").toString("base64url");
+    expect(data.senders[0].id).toBe(expectedId);
+  });
+});
+
+// ── outlook_outreach_scan ──────────────────────────────────────────────────────
+
+describe("outlook_outreach_scan", () => {
+  test("filters out senders with List-Unsubscribe headers", async () => {
+    const msgs: OutlookMessage[] = [
+      makeMessage(
+        "m1",
+        "newsletter@co.com",
+        "Newsletter",
+        "Weekly Update",
+        "2025-01-15T10:00:00Z",
+        [{ name: "List-Unsubscribe", value: "<mailto:unsub@co.com>" }],
+      ),
+      makeMessage(
+        "m2",
+        "outreach@sales.com",
+        "Sales Bot",
+        "Can we chat?",
+        "2025-01-18T10:00:00Z",
+      ),
+      makeMessage(
+        "m3",
+        "outreach@sales.com",
+        "Sales Bot",
+        "Following up",
+        "2025-01-20T10:00:00Z",
+      ),
+      makeMessage(
+        "m4",
+        "friend@gmail.com",
+        "Friend",
+        "Hey!",
+        "2025-01-19T10:00:00Z",
+      ),
+    ];
+
+    mockListMessages.mockImplementationOnce(() =>
+      Promise.resolve({
+        value: msgs.map((m) => ({
+          id: m.id,
+          from: m.from,
+          receivedDateTime: m.receivedDateTime,
+          subject: m.subject,
+        })),
+      }),
+    );
+    mockBatchGetMessages.mockImplementationOnce(() => Promise.resolve(msgs));
+
+    const result = await runOutreachScan({}, fakeContext);
+    expect(result.isError).toBe(false);
+
+    const data = JSON.parse(result.content);
+    expect(data.scan_id).toBeDefined();
+
+    // newsletter@co.com should be excluded (has List-Unsubscribe)
+    const emails = data.senders.map((s: { email: string }) => s.email);
+    expect(emails).not.toContain("newsletter@co.com");
+
+    // outreach@sales.com and friend@gmail.com should be included
+    expect(emails).toContain("outreach@sales.com");
+    expect(emails).toContain("friend@gmail.com");
+
+    // outreach@sales.com should be first (2 messages)
+    const outreachSender = data.senders.find(
+      (s: { email: string }) => s.email === "outreach@sales.com",
+    );
+    expect(outreachSender.message_count).toBe(2);
+
+    // Outreach scan results should not have has_unsubscribe field
+    expect(outreachSender).not.toHaveProperty("has_unsubscribe");
+  });
+
+  test("returns empty results when no messages found", async () => {
+    mockListMessages.mockImplementationOnce(() =>
+      Promise.resolve({ value: [] }),
+    );
+
+    const result = await runOutreachScan({}, fakeContext);
+    expect(result.isError).toBe(false);
+
+    const data = JSON.parse(result.content);
+    expect(data.senders).toHaveLength(0);
+    expect(data.total_scanned).toBe(0);
+  });
+
+  test("stores scan result in shared scan store", async () => {
+    const msgs: OutlookMessage[] = [
+      makeMessage(
+        "m1",
+        "cold@outreach.com",
+        "Cold",
+        "Intro",
+        "2025-01-15T10:00:00Z",
+      ),
+    ];
+
+    mockListMessages.mockImplementationOnce(() =>
+      Promise.resolve({
+        value: msgs.map((m) => ({
+          id: m.id,
+          from: m.from,
+          receivedDateTime: m.receivedDateTime,
+          subject: m.subject,
+        })),
+      }),
+    );
+    mockBatchGetMessages.mockImplementationOnce(() => Promise.resolve(msgs));
+
+    const result = await runOutreachScan({}, fakeContext);
+    const data = JSON.parse(result.content);
+
+    const messageIds = getSenderMessageIds(data.scan_id, [data.senders[0].id]);
+    expect(messageIds).not.toBeNull();
+    expect(messageIds).toContain("m1");
+  });
+
+  test("respects time_range parameter", async () => {
+    mockListMessages.mockImplementationOnce(() =>
+      Promise.resolve({ value: [] }),
+    );
+
+    await runOutreachScan({ time_range: "30d" }, fakeContext);
+
+    // Verify the OData filter uses the correct date range
+    expect(mockListMessages).toHaveBeenCalledTimes(1);
+    const callArgs = mockListMessages.mock.calls[0] as unknown[];
+    const options = callArgs[1] as { filter?: string };
+    expect(options.filter).toMatch(/receivedDateTime ge /);
+
+    // The date in the filter should be approximately 30 days ago
+    const filterDate = options.filter!.replace("receivedDateTime ge ", "");
+    const parsedDate = new Date(filterDate);
+    const thirtyDaysAgo = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000);
+    // Allow 10 seconds of drift for test execution time
+    expect(
+      Math.abs(parsedDate.getTime() - thirtyDaysAgo.getTime()),
+    ).toBeLessThan(10_000);
+  });
+
+  test("excludes sender if ANY of their messages have List-Unsubscribe", async () => {
+    const msgs: OutlookMessage[] = [
+      // This sender has one message WITH unsubscribe and one WITHOUT
+      makeMessage(
+        "m1",
+        "mixed@co.com",
+        "Mixed",
+        "Promo",
+        "2025-01-15T10:00:00Z",
+        [{ name: "List-Unsubscribe", value: "<mailto:unsub@co.com>" }],
+      ),
+      makeMessage(
+        "m2",
+        "mixed@co.com",
+        "Mixed",
+        "Direct",
+        "2025-01-16T10:00:00Z",
+      ),
+      // This sender has no unsubscribe headers
+      makeMessage(
+        "m3",
+        "human@co.com",
+        "Human",
+        "Hi there",
+        "2025-01-17T10:00:00Z",
+      ),
+    ];
+
+    mockListMessages.mockImplementationOnce(() =>
+      Promise.resolve({
+        value: msgs.map((m) => ({
+          id: m.id,
+          from: m.from,
+          receivedDateTime: m.receivedDateTime,
+          subject: m.subject,
+        })),
+      }),
+    );
+    mockBatchGetMessages.mockImplementationOnce(() => Promise.resolve(msgs));
+
+    const result = await runOutreachScan({}, fakeContext);
+    const data = JSON.parse(result.content);
+
+    const emails = data.senders.map((s: { email: string }) => s.email);
+    // mixed@co.com should be excluded because at least one message has List-Unsubscribe
+    expect(emails).not.toContain("mixed@co.com");
+    expect(emails).toContain("human@co.com");
+  });
+
+  test("respects max_senders parameter", async () => {
+    const msgs: OutlookMessage[] = [
+      makeMessage("m1", "a@test.com", "A", "Sub1", "2025-01-15T10:00:00Z"),
+      makeMessage("m2", "b@test.com", "B", "Sub2", "2025-01-16T10:00:00Z"),
+      makeMessage("m3", "c@test.com", "C", "Sub3", "2025-01-17T10:00:00Z"),
+    ];
+
+    mockListMessages.mockImplementationOnce(() =>
+      Promise.resolve({
+        value: msgs.map((m) => ({
+          id: m.id,
+          from: m.from,
+          receivedDateTime: m.receivedDateTime,
+          subject: m.subject,
+        })),
+      }),
+    );
+    mockBatchGetMessages.mockImplementationOnce(() => Promise.resolve(msgs));
+
+    const result = await runOutreachScan({ max_senders: 1 }, fakeContext);
+    const data = JSON.parse(result.content);
+    expect(data.senders).toHaveLength(1);
+  });
+});
+
+// ── time budget ────────────────────────────────────────────────────────────────
+
+describe("time budget enforcement", () => {
+  test("sender digest flags time_budget_exceeded when scan takes too long", async () => {
+    // Simulate a slow listMessages that exceeds the time budget
+    let callCount = 0;
+    mockListMessages.mockImplementation(async () => {
+      callCount++;
+      if (callCount === 1) {
+        // Return a page of results
+        return {
+          value: [
+            {
+              id: "m1",
+              from: { emailAddress: { address: "a@test.com", name: "A" } },
+              receivedDateTime: "2025-01-15T10:00:00Z",
+              hasAttachments: false,
+              subject: "Test",
+            },
+          ],
+        };
+      }
+      // On subsequent calls, sleep long enough to simulate timeout
+      // We can't actually wait 90s, so we test the mechanism by checking
+      // that the time check exists in the output format
+      return { value: [] };
+    });
+
+    mockBatchGetMessages.mockImplementation(() =>
+      Promise.resolve([
+        makeMessage("m1", "a@test.com", "A", "Test", "2025-01-15T10:00:00Z"),
+      ]),
+    );
+
+    const result = await runSenderDigest({}, fakeContext);
+    expect(result.isError).toBe(false);
+
+    const data = JSON.parse(result.content);
+    // The scan completed normally (under time budget) so these flags should not be set
+    expect(data.time_budget_exceeded).toBeUndefined();
+    expect(data.total_scanned).toBe(1);
+  });
+});