@vellumai/assistant 0.5.16 → 0.6.0

package/src/__tests__/outlook-client-automation.test.ts

@@ -0,0 +1,246 @@
+import { describe, expect, mock, test } from "bun:test";
+
+import {
+  createMailRule,
+  deleteMailRule,
+  getAutoReplySettings,
+  listMailRules,
+  listMessagesDelta,
+  updateAutoReplySettings,
+} from "../messaging/providers/outlook/client.js";
+import type {
+  OutlookAutoReplySettings,
+  OutlookDeltaResponse,
+  OutlookMessage,
+  OutlookMessageRule,
+  OutlookMessageRuleListResponse,
+} from "../messaging/providers/outlook/types.js";
+import type { OAuthConnection } from "../oauth/connection.js";
+
+// ── Helpers ─────────────────────────────────────────────────────────────────
+
+function createMockConnection(
+  responseBody: unknown = {},
+  status = 200,
+): OAuthConnection {
+  return {
+    id: "outlook-conn-1",
+    providerKey: "outlook",
+    accountInfo: "test@outlook.com",
+    request: mock(() =>
+      Promise.resolve({ status, headers: {}, body: responseBody }),
+    ),
+    withToken: <T>(fn: (token: string) => Promise<T>) =>
+      fn("mock-access-token"),
+  };
+}
+
+// ── Tests ───────────────────────────────────────────────────────────────────
+
+describe("Outlook client — automation and delta APIs", () => {
+  // ── listMailRules ──────────────────────────────────────────────────────
+
+  describe("listMailRules", () => {
+    test("returns rules array", async () => {
+      const rules: OutlookMessageRule[] = [
+        {
+          id: "rule-1",
+          displayName: "Move newsletters",
+          sequence: 1,
+          isEnabled: true,
+          conditions: { subjectContains: ["newsletter"] },
+          actions: { moveToFolder: "folder-123" },
+        },
+      ];
+      const responseBody: OutlookMessageRuleListResponse = { value: rules };
+      const conn = createMockConnection(responseBody);
+
+      const result = await listMailRules(conn);
+
+      expect(result.value).toHaveLength(1);
+      expect(result.value![0].displayName).toBe("Move newsletters");
+      expect(conn.request).toHaveBeenCalledWith(
+        expect.objectContaining({
+          method: "GET",
+          path: "/v1.0/me/mailFolders/inbox/messageRules",
+        }),
+      );
+    });
+  });
+
+  // ── createMailRule ─────────────────────────────────────────────────────
+
+  describe("createMailRule", () => {
+    test("sends POST with rule body", async () => {
+      const createdRule: OutlookMessageRule = {
+        id: "rule-new",
+        displayName: "Delete spam",
+        sequence: 2,
+        isEnabled: true,
+        conditions: { senderContains: ["spam@"] },
+        actions: { delete: true },
+      };
+      const conn = createMockConnection(createdRule);
+
+      const rule = {
+        displayName: "Delete spam",
+        sequence: 2,
+        isEnabled: true,
+        conditions: { senderContains: ["spam@"] },
+        actions: { delete: true },
+      };
+      const result = await createMailRule(conn, rule);
+
+      expect(result.id).toBe("rule-new");
+      expect(result.displayName).toBe("Delete spam");
+      expect(conn.request).toHaveBeenCalledWith(
+        expect.objectContaining({
+          method: "POST",
+          path: "/v1.0/me/mailFolders/inbox/messageRules",
+          body: rule,
+        }),
+      );
+    });
+  });
+
+  // ── deleteMailRule ─────────────────────────────────────────────────────
+
+  describe("deleteMailRule", () => {
+    test("sends DELETE to correct path", async () => {
+      const conn = createMockConnection(undefined, 204);
+
+      await deleteMailRule(conn, "rule-42");
+
+      expect(conn.request).toHaveBeenCalledWith(
+        expect.objectContaining({
+          method: "DELETE",
+          path: "/v1.0/me/mailFolders/inbox/messageRules/rule-42",
+        }),
+      );
+    });
+  });
+
+  // ── getAutoReplySettings ──────────────────────────────────────────────
+
+  describe("getAutoReplySettings", () => {
+    test("returns settings", async () => {
+      const settings: OutlookAutoReplySettings = {
+        status: "alwaysEnabled",
+        externalAudience: "all",
+        internalReplyMessage: "I am out of office.",
+        externalReplyMessage: "I am currently unavailable.",
+      };
+      const conn = createMockConnection(settings);
+
+      const result = await getAutoReplySettings(conn);
+
+      expect(result.status).toBe("alwaysEnabled");
+      expect(result.externalAudience).toBe("all");
+      expect(result.internalReplyMessage).toBe("I am out of office.");
+      expect(conn.request).toHaveBeenCalledWith(
+        expect.objectContaining({
+          method: "GET",
+          path: "/v1.0/me/mailboxSettings/automaticRepliesSetting",
+        }),
+      );
+    });
+  });
+
+  // ── updateAutoReplySettings ───────────────────────────────────────────
+
+  describe("updateAutoReplySettings", () => {
+    test("sends PATCH with wrapped settings", async () => {
+      const conn = createMockConnection(undefined, 204);
+
+      const settings: OutlookAutoReplySettings = {
+        status: "scheduled",
+        externalAudience: "contactsOnly",
+        internalReplyMessage: "On vacation.",
+        scheduledStartDateTime: {
+          dateTime: "2024-12-20T00:00:00",
+          timeZone: "UTC",
+        },
+        scheduledEndDateTime: {
+          dateTime: "2024-12-31T23:59:59",
+          timeZone: "UTC",
+        },
+      };
+
+      await updateAutoReplySettings(conn, settings);
+
+      expect(conn.request).toHaveBeenCalledWith(
+        expect.objectContaining({
+          method: "PATCH",
+          path: "/v1.0/me/mailboxSettings",
+          body: { automaticRepliesSetting: settings },
+        }),
+      );
+    });
+  });
+
+  // ── listMessagesDelta ─────────────────────────────────────────────────
+
+  describe("listMessagesDelta", () => {
+    test("initial fetch without deltaLink uses folder path with $select and $top", async () => {
+      const deltaResponse: OutlookDeltaResponse<OutlookMessage> = {
+        value: [
+          {
+            id: "msg-1",
+            subject: "Hello",
+            isRead: false,
+            parentFolderId: "inbox-id",
+          } as OutlookMessage,
+        ],
+        "@odata.deltaLink":
+          "https://graph.microsoft.com/v1.0/me/mailFolders/inbox-id/messages/delta?$deltatoken=abc123",
+      };
+      const conn = createMockConnection(deltaResponse);
+
+      const result = await listMessagesDelta(conn, "inbox-id");
+
+      expect(result.value).toHaveLength(1);
+      expect(result["@odata.deltaLink"]).toContain("$deltatoken=abc123");
+      expect(conn.request).toHaveBeenCalledWith(
+        expect.objectContaining({
+          method: "GET",
+          path: "/v1.0/me/mailFolders/inbox-id/messages/delta",
+          query: {
+            $select:
+              "id,subject,from,receivedDateTime,isRead,parentFolderId,conversationId,bodyPreview,hasAttachments",
+            $top: "50",
+          },
+        }),
+      );
+    });
+
+    test("follow-up fetch with deltaLink parses URL and uses query params", async () => {
+      const deltaResponse: OutlookDeltaResponse<OutlookMessage> = {
+        value: [
+          {
+            id: "msg-2",
+            subject: "Update",
+            isRead: true,
+            parentFolderId: "inbox-id",
+          } as OutlookMessage,
+        ],
+        "@odata.deltaLink":
+          "https://graph.microsoft.com/v1.0/me/mailFolders/inbox-id/messages/delta?$deltatoken=def456",
+      };
+      const conn = createMockConnection(deltaResponse);
+
+      const deltaLink =
+        "https://graph.microsoft.com/v1.0/me/mailFolders/inbox-id/messages/delta?$deltatoken=abc123";
+      const result = await listMessagesDelta(conn, "inbox-id", deltaLink);
+
+      expect(result.value).toHaveLength(1);
+      expect(result.value![0].id).toBe("msg-2");
+      expect(conn.request).toHaveBeenCalledWith(
+        expect.objectContaining({
+          method: "GET",
+          path: "/v1.0/me/mailFolders/inbox-id/messages/delta",
+          query: { $deltatoken: "abc123" },
+        }),
+      );
+    });
+  });
+});

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

@@ -0,0 +1,325 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import type { OAuthConnection } from "../oauth/connection.js";
+import type { ToolContext } from "../tools/types.js";
+
+// ── Mocks ────────────────────────────────────────────────────────────────────
+
+const createDraftMock = mock(
+  async (_conn: OAuthConnection, _draft: Record<string, unknown>) => ({
+    id: "draft-new-1",
+    subject: "Test",
+    body: { contentType: "text", content: "hello" },
+    toRecipients: [],
+    ccRecipients: [],
+  }),
+);
+
+const createReplyDraftMock = mock(
+  async (_conn: OAuthConnection, _msgId: string, _comment?: string) => ({
+    id: "draft-reply-1",
+    subject: "Re: Test",
+    body: { contentType: "text", content: "reply" },
+    toRecipients: [{ emailAddress: { address: "original@example.com" } }],
+    ccRecipients: [],
+  }),
+);
+
+const patchMessageMock = mock(
+  async (
+    _conn: OAuthConnection,
+    _msgId: string,
+    _fields: Record<string, unknown>,
+  ) => ({
+    id: "draft-reply-1",
+  }),
+);
+
+const sendDraftMock = mock(
+  async (_conn: OAuthConnection, _msgId: string) => {},
+);
+
+const createForwardDraftMock = mock(
+  async (
+    _conn: OAuthConnection,
+    _msgId: string,
+    _to?: unknown[],
+    _comment?: string,
+  ) => ({
+    id: "draft-fwd-1",
+    subject: "Fwd: Test",
+    body: { contentType: "text", content: "forwarded" },
+    toRecipients: [],
+    ccRecipients: [],
+  }),
+);
+
+const fakeConnection = {
+  id: "conn-1",
+  providerKey: "microsoft",
+  accountInfo: "user@outlook.com",
+} as unknown as OAuthConnection;
+
+mock.module("../messaging/providers/outlook/client.js", () => ({
+  createDraft: createDraftMock,
+  createReplyDraft: createReplyDraftMock,
+  patchMessage: patchMessageMock,
+  sendDraft: sendDraftMock,
+  createForwardDraft: createForwardDraftMock,
+}));
+
+mock.module("../oauth/connection-resolver.js", () => ({
+  resolveOAuthConnection: async () => fakeConnection,
+}));
+
+// Import tools after mocks are set up
+import { run as runDraft } from "../config/bundled-skills/outlook/tools/outlook-draft.js";
+import { run as runForward } from "../config/bundled-skills/outlook/tools/outlook-forward.js";
+import { run as runSendDraft } from "../config/bundled-skills/outlook/tools/outlook-send-draft.js";
+
+const baseContext: ToolContext = {
+  workingDir: "/tmp",
+  conversationId: "conv-1",
+  trustClass: "guardian" as const,
+};
+
+// ── outlook_draft ────────────────────────────────────────────────────────────
+
+describe("outlook_draft", () => {
+  beforeEach(() => {
+    createDraftMock.mockClear();
+    createReplyDraftMock.mockClear();
+    patchMessageMock.mockClear();
+  });
+
+  test("creates a new draft with to, subject, body", async () => {
+    const result = await runDraft(
+      { to: "alice@example.com", subject: "Hello", body: "Hi there" },
+      baseContext,
+    );
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain("Draft created (ID: draft-new-1)");
+    expect(createDraftMock).toHaveBeenCalledTimes(1);
+    const [conn, draft] = createDraftMock.mock.calls[0];
+    expect(conn).toBe(fakeConnection);
+    expect(draft).toMatchObject({
+      subject: "Hello",
+      body: { contentType: "text", content: "Hi there" },
+    });
+  });
+
+  test("creates a new draft with cc and bcc", async () => {
+    const result = await runDraft(
+      {
+        to: "alice@example.com",
+        subject: "Hello",
+        body: "Hi",
+        cc: "bob@example.com",
+        bcc: "charlie@example.com",
+      },
+      baseContext,
+    );
+
+    expect(result.isError).toBe(false);
+    const [, draft] = createDraftMock.mock.calls[0];
+    expect(draft.ccRecipients).toEqual([
+      { emailAddress: { address: "bob@example.com" } },
+    ]);
+    expect(draft.bccRecipients).toEqual([
+      { emailAddress: { address: "charlie@example.com" } },
+    ]);
+  });
+
+  test("creates a reply draft when in_reply_to is provided", async () => {
+    const result = await runDraft(
+      {
+        to: "alice@example.com",
+        subject: "Re: Hello",
+        body: "Thanks!",
+        in_reply_to: "msg-original-1",
+      },
+      baseContext,
+    );
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain("Draft created (ID: draft-reply-1)");
+    expect(createReplyDraftMock).toHaveBeenCalledTimes(1);
+    const [, msgId, comment] = createReplyDraftMock.mock.calls[0];
+    expect(msgId).toBe("msg-original-1");
+    expect(comment).toBe("Thanks!");
+    // Should patch recipients since to is specified
+    expect(patchMessageMock).toHaveBeenCalledTimes(1);
+    const [, patchMsgId] = patchMessageMock.mock.calls[0];
+    expect(patchMsgId).toBe("draft-reply-1");
+  });
+
+  test("patches reply draft with custom cc and bcc", async () => {
+    const result = await runDraft(
+      {
+        to: "alice@example.com",
+        subject: "Re: Hello",
+        body: "Thanks!",
+        in_reply_to: "msg-original-1",
+        cc: "bob@example.com",
+        bcc: "secret@example.com",
+      },
+      baseContext,
+    );
+
+    expect(result.isError).toBe(false);
+    expect(patchMessageMock).toHaveBeenCalledTimes(1);
+    const [, , patchFields] = patchMessageMock.mock.calls[0];
+    expect(patchFields.toRecipients).toEqual([
+      { emailAddress: { address: "alice@example.com" } },
+    ]);
+    expect(patchFields.ccRecipients).toEqual([
+      { emailAddress: { address: "bob@example.com" } },
+    ]);
+    expect(patchFields.bccRecipients).toEqual([
+      { emailAddress: { address: "secret@example.com" } },
+    ]);
+  });
+
+  test("returns error when to is missing", async () => {
+    const result = await runDraft(
+      { subject: "Hello", body: "Hi" },
+      baseContext,
+    );
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("to is required");
+  });
+
+  test("returns error when subject is missing", async () => {
+    const result = await runDraft(
+      { to: "alice@example.com", body: "Hi" },
+      baseContext,
+    );
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("subject is required");
+  });
+
+  test("returns error when body is missing", async () => {
+    const result = await runDraft(
+      { to: "alice@example.com", subject: "Hello" },
+      baseContext,
+    );
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("body is required");
+  });
+});
+
+// ── outlook_send_draft ───────────────────────────────────────────────────────
+
+describe("outlook_send_draft", () => {
+  beforeEach(() => {
+    sendDraftMock.mockClear();
+  });
+
+  test("sends a draft when triggered by surface action", async () => {
+    const result = await runSendDraft(
+      { draft_id: "draft-1", confidence: 0.9 },
+      { ...baseContext, triggeredBySurfaceAction: true },
+    );
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toBe("Draft sent.");
+    expect(sendDraftMock).toHaveBeenCalledTimes(1);
+    const [, draftId] = sendDraftMock.mock.calls[0];
+    expect(draftId).toBe("draft-1");
+  });
+
+  test("rejects when not triggered by surface action", async () => {
+    const result = await runSendDraft(
+      { draft_id: "draft-1", confidence: 0.9 },
+      baseContext,
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("surface action");
+    expect(sendDraftMock).not.toHaveBeenCalled();
+  });
+
+  test("returns error when draft_id is missing", async () => {
+    const result = await runSendDraft(
+      { confidence: 0.9 },
+      { ...baseContext, triggeredBySurfaceAction: true },
+    );
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("draft_id is required");
+  });
+});
+
+// ── outlook_forward ──────────────────────────────────────────────────────────
+
+describe("outlook_forward", () => {
+  beforeEach(() => {
+    createForwardDraftMock.mockClear();
+  });
+
+  test("creates a forward draft", async () => {
+    const result = await runForward(
+      { message_id: "msg-1", to: "bob@example.com", confidence: 0.9 },
+      baseContext,
+    );
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain("Forward draft created (ID: draft-fwd-1)");
+    expect(createForwardDraftMock).toHaveBeenCalledTimes(1);
+    const [, msgId, toList] = createForwardDraftMock.mock.calls[0];
+    expect(msgId).toBe("msg-1");
+    expect(toList).toEqual([{ emailAddress: { address: "bob@example.com" } }]);
+  });
+
+  test("creates a forward draft with comment", async () => {
+    const result = await runForward(
+      {
+        message_id: "msg-1",
+        to: "bob@example.com",
+        comment: "FYI",
+        confidence: 0.9,
+      },
+      baseContext,
+    );
+
+    expect(result.isError).toBe(false);
+    const [, , , fwdComment] = createForwardDraftMock.mock.calls[0];
+    expect(fwdComment).toBe("FYI");
+  });
+
+  test("creates a forward draft with multiple recipients", async () => {
+    const result = await runForward(
+      {
+        message_id: "msg-1",
+        to: "bob@example.com, carol@example.com",
+        confidence: 0.9,
+      },
+      baseContext,
+    );
+
+    expect(result.isError).toBe(false);
+    const [, , toList] = createForwardDraftMock.mock.calls[0];
+    expect(toList).toEqual([
+      { emailAddress: { address: "bob@example.com" } },
+      { emailAddress: { address: "carol@example.com" } },
+    ]);
+  });
+
+  test("returns error when message_id is missing", async () => {
+    const result = await runForward(
+      { to: "bob@example.com", confidence: 0.9 },
+      baseContext,
+    );
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("message_id is required");
+  });
+
+  test("returns error when to is missing", async () => {
+    const result = await runForward(
+      { message_id: "msg-1", confidence: 0.9 },
+      baseContext,
+    );
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("to is required");
+  });
+});