@vellumai/assistant 0.4.26 → 0.4.29

package/src/watcher/providers/gmail.ts

@@ -6,15 +6,22 @@
  * Falls back to listing recent unread messages if the historyId has expired (404).
  */
 
-import { batchGetMessages,getProfile } from '../../messaging/providers/gmail/client.js';
-import type { GmailMessage } from '../../messaging/providers/gmail/types.js';
-import { withValidToken } from '../../security/token-manager.js';
-import { getLogger } from '../../util/logger.js';
-import type { FetchResult,WatcherItem, WatcherProvider } from '../provider-types.js';
-
-const log = getLogger('watcher:gmail');
-
-const GMAIL_API_BASE = 'https://gmail.googleapis.com/gmail/v1/users/me';
+import {
+  batchGetMessages,
+  getProfile,
+} from "../../messaging/providers/gmail/client.js";
+import type { GmailMessage } from "../../messaging/providers/gmail/types.js";
+import { withValidToken } from "../../security/token-manager.js";
+import { getLogger } from "../../util/logger.js";
+import type {
+  FetchResult,
+  WatcherItem,
+  WatcherProvider,
+} from "../provider-types.js";
+
+const log = getLogger("watcher:gmail");
+
+const GMAIL_API_BASE = "https://gmail.googleapis.com/gmail/v1/users/me";
 
 /** Gmail History API response types */
 interface HistoryMessage {
@@ -34,19 +41,21 @@ interface HistoryListResponse {
 }
 
 function extractHeader(msg: GmailMessage, name: string): string {
-  return msg.payload?.headers?.find(
-    (h) => h.name.toLowerCase() === name.toLowerCase(),
-  )?.value ?? '';
+  return (
+    msg.payload?.headers?.find(
+      (h) => h.name.toLowerCase() === name.toLowerCase(),
+    )?.value ?? ""
+  );
 }
 
 function messageToItem(msg: GmailMessage): WatcherItem {
-  const from = extractHeader(msg, 'From');
-  const subject = extractHeader(msg, 'Subject');
-  const date = extractHeader(msg, 'Date');
+  const from = extractHeader(msg, "From");
+  const subject = extractHeader(msg, "Subject");
+  const date = extractHeader(msg, "Date");
 
   return {
     externalId: msg.id,
-    eventType: 'new_email',
+    eventType: "new_email",
     summary: `Email from ${from}: ${subject}`,
     payload: {
       id: msg.id,
@@ -54,7 +63,7 @@ function messageToItem(msg: GmailMessage): WatcherItem {
       from,
       subject,
       date,
-      snippet: msg.snippet ?? '',
+      snippet: msg.snippet ?? "",
       labelIds: msg.labelIds ?? [],
     },
     timestamp: msg.internalDate ? parseInt(msg.internalDate, 10) : Date.now(),
@@ -67,8 +76,8 @@ async function fetchHistory(
 ): Promise<HistoryListResponse> {
   const params = new URLSearchParams({
     startHistoryId,
-    historyTypes: 'messageAdded',
-    maxResults: '100',
+    historyTypes: "messageAdded",
+    maxResults: "100",
   });
   const url = `${GMAIL_API_BASE}/history?${params}`;
   const resp = await fetch(url, {
@@ -76,7 +85,7 @@ async function fetchHistory(
   });
 
   if (!resp.ok) {
-    const body = await resp.text().catch(() => '');
+    const body = await resp.text().catch(() => "");
     if (resp.status === 404) {
       // historyId expired — caller handles fallback
       throw new HistoryExpiredError(body);
@@ -90,20 +99,20 @@ async function fetchHistory(
 class HistoryExpiredError extends Error {
   constructor(message: string) {
     super(message);
-    this.name = 'HistoryExpiredError';
+    this.name = "HistoryExpiredError";
   }
 }
 
 export const gmailProvider: WatcherProvider = {
-  id: 'gmail',
-  displayName: 'Gmail',
-  requiredCredentialService: 'integration:gmail',
+  id: "gmail",
+  displayName: "Gmail",
+  requiredCredentialService: "integration:gmail",
 
   async getInitialWatermark(credentialService: string): Promise<string> {
     return withValidToken(credentialService, async (token) => {
       const profile = await getProfile(token);
       if (!profile.historyId) {
-        throw new Error('Gmail profile did not return a historyId');
+        throw new Error("Gmail profile did not return a historyId");
       }
       return profile.historyId;
     });
@@ -119,7 +128,7 @@ export const gmailProvider: WatcherProvider = {
       if (!watermark) {
         // No watermark — get initial position, return no items
         const profile = await getProfile(token);
-        return { items: [], watermark: profile.historyId ?? '0' };
+        return { items: [], watermark: profile.historyId ?? "0" };
       }
 
       try {
@@ -148,22 +157,27 @@ export const gmailProvider: WatcherProvider = {
         const messages = await batchGetMessages(
           token,
           Array.from(messageIds),
-          'metadata',
-          ['From', 'Subject', 'Date'],
+          "metadata",
+          ["From", "Subject", "Date"],
         );
 
         // Only include INBOX messages (skip sent, drafts, etc.)
-        const inboxMessages = messages.filter(
-          (m) => m.labelIds?.includes('INBOX'),
+        const inboxMessages = messages.filter((m) =>
+          m.labelIds?.includes("INBOX"),
         );
 
         const items = inboxMessages.map(messageToItem);
-        log.info({ count: items.length, watermark: newWatermark }, 'Gmail: fetched new messages');
+        log.info(
+          { count: items.length, watermark: newWatermark },
+          "Gmail: fetched new messages",
+        );
 
         return { items, watermark: newWatermark };
       } catch (err) {
         if (err instanceof HistoryExpiredError) {
-          log.warn('Gmail historyId expired, falling back to recent unread messages');
+          log.warn(
+            "Gmail historyId expired, falling back to recent unread messages",
+          );
           return fallbackFetch(token);
         }
         throw err;
@@ -176,24 +190,31 @@ export const gmailProvider: WatcherProvider = {
  * Fallback when historyId expires: list recent unread inbox messages.
  */
 async function fallbackFetch(token: string): Promise<FetchResult> {
-  const { listMessages } = await import('../../messaging/providers/gmail/client.js');
-  const listResp = await listMessages(token, 'is:unread newer_than:1d', 20, undefined, ['INBOX']);
+  const { listMessages } =
+    await import("../../messaging/providers/gmail/client.js");
+  const listResp = await listMessages(
+    token,
+    "is:unread newer_than:1d",
+    20,
+    undefined,
+    ["INBOX"],
+  );
 
   if (!listResp.messages || listResp.messages.length === 0) {
     const profile = await getProfile(token);
-    return { items: [], watermark: profile.historyId ?? '0' };
+    return { items: [], watermark: profile.historyId ?? "0" };
   }
 
   const messages = await batchGetMessages(
     token,
     listResp.messages.map((m) => m.id),
-    'metadata',
-    ['From', 'Subject', 'Date'],
+    "metadata",
+    ["From", "Subject", "Date"],
   );
 
   const items = messages.map(messageToItem);
 
   // Get fresh historyId for the new watermark
   const profile = await getProfile(token);
-  return { items, watermark: profile.historyId ?? '0' };
+  return { items, watermark: profile.historyId ?? "0" };
 }

package/src/watcher/providers/google-calendar.ts

@@ -6,48 +6,54 @@
  * Falls back to listing recent upcoming events if the syncToken has expired (410 Gone).
  */
 
-import { CalendarApiError,listEvents } from '../../config/bundled-skills/google-calendar/calendar-client.js';
-import type { CalendarEvent } from '../../config/bundled-skills/google-calendar/types.js';
-import { withValidToken } from '../../security/token-manager.js';
-import { getLogger } from '../../util/logger.js';
-import type { FetchResult,WatcherItem, WatcherProvider } from '../provider-types.js';
-
-const log = getLogger('watcher:google-calendar');
-
-const CALENDAR_API_BASE = 'https://www.googleapis.com/calendar/v3';
+import {
+  CalendarApiError,
+  listEvents,
+} from "../../config/bundled-skills/google-calendar/calendar-client.js";
+import type { CalendarEvent } from "../../config/bundled-skills/google-calendar/types.js";
+import { withValidToken } from "../../security/token-manager.js";
+import { getLogger } from "../../util/logger.js";
+import type {
+  FetchResult,
+  WatcherItem,
+  WatcherProvider,
+} from "../provider-types.js";
+
+const log = getLogger("watcher:google-calendar");
+
+const CALENDAR_API_BASE = "https://www.googleapis.com/calendar/v3";
 
 /** The credential service — calendar shares OAuth tokens with Gmail. */
-const CREDENTIAL_SERVICE = 'integration:gmail';
+const CREDENTIAL_SERVICE = "integration:gmail";
 
 function eventToItem(event: CalendarEvent, eventType: string): WatcherItem {
-  const start = event.start?.dateTime ?? event.start?.date ?? '';
-  const end = event.end?.dateTime ?? event.end?.date ?? '';
+  const start = event.start?.dateTime ?? event.start?.date ?? "";
+  const end = event.end?.dateTime ?? event.end?.date ?? "";
 
   // Include updated timestamp in the dedup key so subsequent edits to the
   // same event aren't silently dropped by the watcher_id + external_id constraint.
-  const version = event.updated ?? '';
+  const version = event.updated ?? "";
   return {
     externalId: version ? `${event.id}@${version}` : event.id,
     eventType,
-    summary: `Calendar event: ${event.summary ?? '(no title)'} — ${start}`,
+    summary: `Calendar event: ${event.summary ?? "(no title)"} — ${start}`,
     payload: {
       id: event.id,
-      summary: event.summary ?? '',
+      summary: event.summary ?? "",
       start,
       end,
-      location: event.location ?? '',
-      description: event.description ?? '',
-      status: event.status ?? 'confirmed',
-      organizer: event.organizer?.email ?? '',
-      attendees: event.attendees?.map((a) => ({
-        email: a.email,
-        responseStatus: a.responseStatus,
-      })) ?? [],
-      htmlLink: event.htmlLink ?? '',
+      location: event.location ?? "",
+      description: event.description ?? "",
+      status: event.status ?? "confirmed",
+      organizer: event.organizer?.email ?? "",
+      attendees:
+        event.attendees?.map((a) => ({
+          email: a.email,
+          responseStatus: a.responseStatus,
+        })) ?? [],
+      htmlLink: event.htmlLink ?? "",
     },
-    timestamp: event.updated
-      ? new Date(event.updated).getTime()
-      : Date.now(),
+    timestamp: event.updated ? new Date(event.updated).getTime() : Date.now(),
   };
 }
 
@@ -72,19 +78,23 @@ async function incrementalSync(
 
   do {
     const params = new URLSearchParams({ syncToken });
-    if (pageToken) params.set('pageToken', pageToken);
+    if (pageToken) params.set("pageToken", pageToken);
     const url = `${CALENDAR_API_BASE}/calendars/primary/events?${params}`;
     const resp = await fetch(url, {
       headers: { Authorization: `Bearer ${token}` },
     });
 
     if (!resp.ok) {
-      const body = await resp.text().catch(() => '');
+      const body = await resp.text().catch(() => "");
       if (resp.status === 410) {
         throw new SyncTokenExpiredError(body);
       }
       // Throw CalendarApiError so withValidToken can detect 401s via the status property
-      throw new CalendarApiError(resp.status, resp.statusText, `Calendar Sync API ${resp.status}: ${body}`);
+      throw new CalendarApiError(
+        resp.status,
+        resp.statusText,
+        `Calendar Sync API ${resp.status}: ${body}`,
+      );
     }
 
     const page = (await resp.json()) as SyncResponse;
@@ -99,13 +109,13 @@ async function incrementalSync(
 class SyncTokenExpiredError extends Error {
   constructor(message: string) {
     super(message);
-    this.name = 'SyncTokenExpiredError';
+    this.name = "SyncTokenExpiredError";
   }
 }
 
 export const googleCalendarProvider: WatcherProvider = {
-  id: 'google-calendar',
-  displayName: 'Google Calendar',
+  id: "google-calendar",
+  displayName: "Google Calendar",
   requiredCredentialService: CREDENTIAL_SERVICE,
 
   async getInitialWatermark(credentialService: string): Promise<string> {
@@ -118,7 +128,7 @@ export const googleCalendarProvider: WatcherProvider = {
       let syncToken: string | undefined;
 
       do {
-        const result = await listEvents(token, 'primary', {
+        const result = await listEvents(token, "primary", {
           timeMin: now,
           maxResults: 250,
           singleEvents: true,
@@ -129,7 +139,7 @@ export const googleCalendarProvider: WatcherProvider = {
       } while (pageToken && !syncToken);
 
       if (!syncToken) {
-        throw new Error('Calendar API did not return a syncToken');
+        throw new Error("Calendar API did not return a syncToken");
       }
       return syncToken;
     });
@@ -149,7 +159,7 @@ export const googleCalendarProvider: WatcherProvider = {
         let syncToken: string | undefined;
 
         do {
-          const result = await listEvents(token, 'primary', {
+          const result = await listEvents(token, "primary", {
             timeMin: now,
             maxResults: 250,
             singleEvents: true,
@@ -159,7 +169,7 @@ export const googleCalendarProvider: WatcherProvider = {
           pageToken = result.nextPageToken;
         } while (pageToken && !syncToken);
 
-        return { items: [], watermark: syncToken ?? '' };
+        return { items: [], watermark: syncToken ?? "" };
       }
 
       try {
@@ -173,19 +183,23 @@ export const googleCalendarProvider: WatcherProvider = {
         // Convert events to watcher items, distinguishing new vs updated
         const items: WatcherItem[] = [];
         for (const event of syncResp.items) {
-          if (event.status === 'cancelled') continue;
+          if (event.status === "cancelled") continue;
 
-          const eventType = event.created === event.updated
-            ? 'new_calendar_event'
-            : 'updated_calendar_event';
+          const eventType =
+            event.created === event.updated
+              ? "new_calendar_event"
+              : "updated_calendar_event";
           items.push(eventToItem(event, eventType));
         }
 
-        log.info({ count: items.length, watermark: newWatermark }, 'Calendar: fetched event changes');
+        log.info(
+          { count: items.length, watermark: newWatermark },
+          "Calendar: fetched event changes",
+        );
         return { items, watermark: newWatermark };
       } catch (err) {
         if (err instanceof SyncTokenExpiredError) {
-          log.warn('Calendar syncToken expired, falling back to recent events');
+          log.warn("Calendar syncToken expired, falling back to recent events");
           return fallbackFetch(token);
         }
         throw err;
@@ -199,15 +213,15 @@ export const googleCalendarProvider: WatcherProvider = {
  */
 async function fallbackFetch(token: string): Promise<FetchResult> {
   const now = new Date().toISOString();
-  const result = await listEvents(token, 'primary', {
+  const result = await listEvents(token, "primary", {
     timeMin: now,
     maxResults: 25,
     singleEvents: true,
-    orderBy: 'startTime',
+    orderBy: "startTime",
   });
 
   const items = (result.items ?? []).map((event) =>
-    eventToItem(event, 'new_calendar_event'),
+    eventToItem(event, "new_calendar_event"),
   );
 
   // Paginate through to get a fresh syncToken for the next watermark
@@ -215,7 +229,7 @@ async function fallbackFetch(token: string): Promise<FetchResult> {
   let syncToken: string | undefined;
 
   do {
-    const syncResult = await listEvents(token, 'primary', {
+    const syncResult = await listEvents(token, "primary", {
       timeMin: now,
       maxResults: 250,
       singleEvents: true,
@@ -225,5 +239,5 @@ async function fallbackFetch(token: string): Promise<FetchResult> {
     pageToken = syncResult.nextPageToken;
   } while (pageToken && !syncToken);
 
-  return { items, watermark: syncToken ?? '' };
+  return { items, watermark: syncToken ?? "" };
 }