@agenticmail/enterprise 0.5.48 → 0.5.50

package/src/agenticmail/providers/google.ts

@@ -0,0 +1,331 @@
+/**
+ * Gmail API Email Provider
+ *
+ * Implements IEmailProvider using Gmail REST API.
+ * Agent authenticates via org's Google Workspace OAuth.
+ * Email address comes from the org directory.
+ */
+
+import type {
+  IEmailProvider, AgentEmailIdentity, EmailProvider,
+  EmailMessage, EmailEnvelope, EmailFolder,
+  SendEmailOptions, SearchCriteria,
+} from '../types.js';
+
+const GMAIL_BASE = 'https://gmail.googleapis.com/gmail/v1';
+
+export class GoogleEmailProvider implements IEmailProvider {
+  readonly provider: EmailProvider = 'google';
+  private identity: AgentEmailIdentity | null = null;
+  private userId = 'me';
+
+  private get token(): string {
+    if (!this.identity) throw new Error('Not connected');
+    return this.identity.accessToken;
+  }
+
+  private async refreshIfNeeded(): Promise<void> {
+    if (this.identity?.refreshToken) {
+      this.identity.accessToken = await this.identity.refreshToken();
+    }
+  }
+
+  private async gmailFetch(path: string, opts?: RequestInit): Promise<any> {
+    await this.refreshIfNeeded();
+    const res = await fetch(`${GMAIL_BASE}/users/${this.userId}${path}`, {
+      ...opts,
+      headers: {
+        Authorization: `Bearer ${this.token}`,
+        'Content-Type': 'application/json',
+        ...opts?.headers,
+      },
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => '');
+      throw new Error(`Gmail API ${res.status}: ${text}`);
+    }
+    if (res.status === 204) return null;
+    return res.json();
+  }
+
+  // ─── Connection ─────────────────────────────────────
+
+  async connect(identity: AgentEmailIdentity): Promise<void> {
+    this.identity = identity;
+    // Validate token
+    await this.gmailFetch('/profile');
+  }
+
+  async disconnect(): Promise<void> {
+    this.identity = null;
+  }
+
+  // ─── List / Read ────────────────────────────────────
+
+  async listMessages(folder: string, opts?: { limit?: number; offset?: number }): Promise<EmailEnvelope[]> {
+    const labelId = this.resolveLabelId(folder);
+    const maxResults = opts?.limit || 20;
+    const q = labelId === 'INBOX' ? '' : '';
+    const data = await this.gmailFetch(`/messages?labelIds=${labelId}&maxResults=${maxResults}${q ? '&q=' + encodeURIComponent(q) : ''}`);
+
+    if (!data.messages?.length) return [];
+
+    // Batch fetch message metadata
+    const envelopes: EmailEnvelope[] = [];
+    for (const msg of data.messages) {
+      try {
+        const detail = await this.gmailFetch(`/messages/${msg.id}?format=metadata&metadataHeaders=From&metadataHeaders=To&metadataHeaders=Subject&metadataHeaders=Date`);
+        envelopes.push(this.metadataToEnvelope(detail));
+      } catch { /* skip individual errors */ }
+    }
+    return envelopes;
+  }
+
+  async readMessage(uid: string): Promise<EmailMessage> {
+    const data = await this.gmailFetch(`/messages/${uid}?format=full`);
+    return this.fullToMessage(data);
+  }
+
+  async searchMessages(criteria: SearchCriteria): Promise<EmailEnvelope[]> {
+    const parts: string[] = [];
+    if (criteria.from) parts.push(`from:${criteria.from}`);
+    if (criteria.to) parts.push(`to:${criteria.to}`);
+    if (criteria.subject) parts.push(`subject:${criteria.subject}`);
+    if (criteria.text) parts.push(criteria.text);
+    if (criteria.since) parts.push(`after:${criteria.since.split('T')[0]}`);
+    if (criteria.before) parts.push(`before:${criteria.before.split('T')[0]}`);
+    if (criteria.seen === true) parts.push('is:read');
+    if (criteria.seen === false) parts.push('is:unread');
+
+    const q = parts.join(' ');
+    const data = await this.gmailFetch(`/messages?q=${encodeURIComponent(q)}&maxResults=50`);
+
+    if (!data.messages?.length) return [];
+
+    const envelopes: EmailEnvelope[] = [];
+    for (const msg of data.messages.slice(0, 20)) {
+      try {
+        const detail = await this.gmailFetch(`/messages/${msg.id}?format=metadata&metadataHeaders=From&metadataHeaders=To&metadataHeaders=Subject&metadataHeaders=Date`);
+        envelopes.push(this.metadataToEnvelope(detail));
+      } catch { /* skip */ }
+    }
+    return envelopes;
+  }
+
+  async listFolders(): Promise<EmailFolder[]> {
+    const data = await this.gmailFetch('/labels');
+    return (data.labels || []).map((l: any) => ({
+      name: l.name,
+      path: l.id,
+      unread: l.messagesUnread || 0,
+      total: l.messagesTotal || 0,
+    }));
+  }
+
+  async createFolder(name: string): Promise<void> {
+    await this.gmailFetch('/labels', {
+      method: 'POST',
+      body: JSON.stringify({ name, labelListVisibility: 'labelShow', messageListVisibility: 'show' }),
+    });
+  }
+
+  // ─── Send ───────────────────────────────────────────
+
+  async send(options: SendEmailOptions): Promise<{ messageId: string }> {
+    const raw = this.buildRawEmail(options);
+    const data = await this.gmailFetch('/messages/send', {
+      method: 'POST',
+      body: JSON.stringify({ raw }),
+    });
+    return { messageId: data.id };
+  }
+
+  async reply(uid: string, body: string, replyAll = false): Promise<{ messageId: string }> {
+    const original = await this.readMessage(uid);
+    const to = replyAll
+      ? [original.from.email, ...(original.to || []).map(t => t.email), ...(original.cc || []).map(c => c.email)].filter(e => e !== this.identity?.email).join(', ')
+      : original.from.email;
+
+    return this.send({
+      to,
+      subject: original.subject.startsWith('Re:') ? original.subject : `Re: ${original.subject}`,
+      body,
+      inReplyTo: original.messageId,
+      references: original.references ? [...original.references, original.messageId!] : [original.messageId!],
+    });
+  }
+
+  async forward(uid: string, to: string, body?: string): Promise<{ messageId: string }> {
+    const original = await this.readMessage(uid);
+    return this.send({
+      to,
+      subject: `Fwd: ${original.subject}`,
+      body: (body ? body + '\n\n' : '') + `---------- Forwarded message ----------\nFrom: ${original.from.email}\nDate: ${original.date}\nSubject: ${original.subject}\n\n${original.body}`,
+    });
+  }
+
+  // ─── Organize ───────────────────────────────────────
+
+  async moveMessage(uid: string, toFolder: string, fromFolder?: string): Promise<void> {
+    const addLabel = this.resolveLabelId(toFolder);
+    const removeLabel = fromFolder ? this.resolveLabelId(fromFolder) : 'INBOX';
+    await this.gmailFetch(`/messages/${uid}/modify`, {
+      method: 'POST',
+      body: JSON.stringify({ addLabelIds: [addLabel], removeLabelIds: [removeLabel] }),
+    });
+  }
+
+  async deleteMessage(uid: string): Promise<void> {
+    await this.gmailFetch(`/messages/${uid}/trash`, { method: 'POST' });
+  }
+
+  async markRead(uid: string): Promise<void> {
+    await this.gmailFetch(`/messages/${uid}/modify`, {
+      method: 'POST',
+      body: JSON.stringify({ removeLabelIds: ['UNREAD'] }),
+    });
+  }
+
+  async markUnread(uid: string): Promise<void> {
+    await this.gmailFetch(`/messages/${uid}/modify`, {
+      method: 'POST',
+      body: JSON.stringify({ addLabelIds: ['UNREAD'] }),
+    });
+  }
+
+  async flagMessage(uid: string): Promise<void> {
+    await this.gmailFetch(`/messages/${uid}/modify`, {
+      method: 'POST',
+      body: JSON.stringify({ addLabelIds: ['STARRED'] }),
+    });
+  }
+
+  async unflagMessage(uid: string): Promise<void> {
+    await this.gmailFetch(`/messages/${uid}/modify`, {
+      method: 'POST',
+      body: JSON.stringify({ removeLabelIds: ['STARRED'] }),
+    });
+  }
+
+  // ─── Batch ──────────────────────────────────────────
+
+  async batchMarkRead(uids: string[]): Promise<void> {
+    await this.gmailFetch('/messages/batchModify', {
+      method: 'POST',
+      body: JSON.stringify({ ids: uids, removeLabelIds: ['UNREAD'] }),
+    });
+  }
+
+  async batchMarkUnread(uids: string[]): Promise<void> {
+    await this.gmailFetch('/messages/batchModify', {
+      method: 'POST',
+      body: JSON.stringify({ ids: uids, addLabelIds: ['UNREAD'] }),
+    });
+  }
+
+  async batchMove(uids: string[], toFolder: string, fromFolder?: string): Promise<void> {
+    const addLabel = this.resolveLabelId(toFolder);
+    const removeLabel = fromFolder ? this.resolveLabelId(fromFolder) : 'INBOX';
+    await this.gmailFetch('/messages/batchModify', {
+      method: 'POST',
+      body: JSON.stringify({ ids: uids, addLabelIds: [addLabel], removeLabelIds: [removeLabel] }),
+    });
+  }
+
+  async batchDelete(uids: string[]): Promise<void> {
+    await Promise.all(uids.map(uid => this.deleteMessage(uid)));
+  }
+
+  // ─── Helpers ────────────────────────────────────────
+
+  private resolveLabelId(folder: string): string {
+    const map: Record<string, string> = {
+      INBOX: 'INBOX', inbox: 'INBOX',
+      Sent: 'SENT', sent: 'SENT',
+      Drafts: 'DRAFT', drafts: 'DRAFT',
+      Trash: 'TRASH', trash: 'TRASH',
+      Spam: 'SPAM', spam: 'SPAM', Junk: 'SPAM', junk: 'SPAM',
+      Starred: 'STARRED', starred: 'STARRED',
+      Important: 'IMPORTANT', important: 'IMPORTANT',
+    };
+    return map[folder] || folder;
+  }
+
+  private buildRawEmail(options: SendEmailOptions): string {
+    const lines = [
+      `To: ${options.to}`,
+      `Subject: ${options.subject}`,
+      `Content-Type: text/plain; charset=utf-8`,
+    ];
+    if (options.cc) lines.splice(1, 0, `Cc: ${options.cc}`);
+    if (options.inReplyTo) lines.push(`In-Reply-To: ${options.inReplyTo}`);
+    if (options.references?.length) lines.push(`References: ${options.references.join(' ')}`);
+    lines.push('', options.body);
+
+    const raw = lines.join('\r\n');
+    // Base64url encode
+    return btoa(unescape(encodeURIComponent(raw)))
+      .replace(/\+/g, '-')
+      .replace(/\//g, '_')
+      .replace(/=+$/, '');
+  }
+
+  private getHeader(msg: any, name: string): string {
+    const headers = msg.payload?.headers || [];
+    const h = headers.find((h: any) => h.name.toLowerCase() === name.toLowerCase());
+    return h?.value || '';
+  }
+
+  private metadataToEnvelope(msg: any): EmailEnvelope {
+    const from = this.getHeader(msg, 'From');
+    const fromMatch = from.match(/^(.*?)\s*<(.+?)>$/) || [null, '', from];
+    return {
+      uid: msg.id,
+      from: { name: fromMatch[1]?.replace(/"/g, '').trim() || undefined, email: fromMatch[2] || from },
+      to: [{ email: this.getHeader(msg, 'To') }],
+      subject: this.getHeader(msg, 'Subject'),
+      date: this.getHeader(msg, 'Date'),
+      read: !(msg.labelIds || []).includes('UNREAD'),
+      flagged: (msg.labelIds || []).includes('STARRED'),
+      hasAttachments: false,
+      preview: msg.snippet || '',
+    };
+  }
+
+  private fullToMessage(msg: any): EmailMessage {
+    const from = this.getHeader(msg, 'From');
+    const fromMatch = from.match(/^(.*?)\s*<(.+?)>$/) || [null, '', from];
+
+    // Extract body from parts
+    let body = '';
+    let html: string | undefined;
+    const extractBody = (payload: any) => {
+      if (payload.mimeType === 'text/plain' && payload.body?.data) {
+        body = Buffer.from(payload.body.data, 'base64url').toString('utf-8');
+      }
+      if (payload.mimeType === 'text/html' && payload.body?.data) {
+        html = Buffer.from(payload.body.data, 'base64url').toString('utf-8');
+      }
+      if (payload.parts) payload.parts.forEach(extractBody);
+    };
+    if (msg.payload) extractBody(msg.payload);
+
+    return {
+      uid: msg.id,
+      from: { name: fromMatch[1]?.replace(/"/g, '').trim() || undefined, email: fromMatch[2] || from },
+      to: [{ email: this.getHeader(msg, 'To') }],
+      cc: this.getHeader(msg, 'Cc') ? [{ email: this.getHeader(msg, 'Cc') }] : undefined,
+      subject: this.getHeader(msg, 'Subject'),
+      body,
+      html,
+      date: this.getHeader(msg, 'Date'),
+      read: !(msg.labelIds || []).includes('UNREAD'),
+      flagged: (msg.labelIds || []).includes('STARRED'),
+      folder: (msg.labelIds || []).includes('INBOX') ? 'inbox' : 'other',
+      messageId: this.getHeader(msg, 'Message-ID'),
+      inReplyTo: this.getHeader(msg, 'In-Reply-To') || undefined,
+      references: this.getHeader(msg, 'References') ? this.getHeader(msg, 'References').split(/\s+/) : undefined,
+      attachments: [],
+    };
+  }
+}

package/src/agenticmail/providers/index.ts

@@ -0,0 +1,26 @@
+/**
+ * Email Provider Factory
+ *
+ * Creates the right email provider based on the org's identity provider.
+ * - Microsoft 365 / Azure AD → Microsoft Graph API
+ * - Google Workspace → Gmail API
+ * - Generic IMAP/SMTP → IMAP provider (future)
+ */
+
+export { MicrosoftEmailProvider } from './microsoft.js';
+export { GoogleEmailProvider } from './google.js';
+
+import type { IEmailProvider, EmailProvider } from '../types.js';
+import { MicrosoftEmailProvider } from './microsoft.js';
+import { GoogleEmailProvider } from './google.js';
+
+export function createEmailProvider(provider: EmailProvider): IEmailProvider {
+  switch (provider) {
+    case 'microsoft': return new MicrosoftEmailProvider();
+    case 'google': return new GoogleEmailProvider();
+    case 'imap':
+      throw new Error('Generic IMAP provider not yet implemented — use Microsoft or Google');
+    default:
+      throw new Error(`Unknown email provider: ${provider}`);
+  }
+}

package/src/agenticmail/providers/microsoft.ts

@@ -0,0 +1,260 @@
+/**
+ * Microsoft Graph Email Provider
+ *
+ * Implements IEmailProvider using Microsoft Graph API.
+ * Agent authenticates via org's Azure AD / Entra ID OAuth.
+ * Email address comes from the org directory.
+ */
+
+import type {
+  IEmailProvider, AgentEmailIdentity, EmailProvider,
+  EmailMessage, EmailEnvelope, EmailFolder,
+  SendEmailOptions, SearchCriteria,
+} from '../types.js';
+
+const GRAPH_BASE = 'https://graph.microsoft.com/v1.0';
+
+export class MicrosoftEmailProvider implements IEmailProvider {
+  readonly provider: EmailProvider = 'microsoft';
+  private identity: AgentEmailIdentity | null = null;
+
+  private get token(): string {
+    if (!this.identity) throw new Error('Not connected');
+    return this.identity.accessToken;
+  }
+
+  private async refreshIfNeeded(): Promise<void> {
+    if (this.identity?.refreshToken) {
+      this.identity.accessToken = await this.identity.refreshToken();
+    }
+  }
+
+  private async graphFetch(path: string, opts?: RequestInit): Promise<any> {
+    await this.refreshIfNeeded();
+    const res = await fetch(`${GRAPH_BASE}${path}`, {
+      ...opts,
+      headers: {
+        Authorization: `Bearer ${this.token}`,
+        'Content-Type': 'application/json',
+        ...opts?.headers,
+      },
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => '');
+      throw new Error(`Graph API ${res.status}: ${text}`);
+    }
+    if (res.status === 204) return null;
+    return res.json();
+  }
+
+  // ─── Connection ─────────────────────────────────────
+
+  async connect(identity: AgentEmailIdentity): Promise<void> {
+    this.identity = identity;
+    // Validate token by fetching profile
+    await this.graphFetch('/me?$select=mail,displayName');
+  }
+
+  async disconnect(): Promise<void> {
+    this.identity = null;
+  }
+
+  // ─── List / Read ────────────────────────────────────
+
+  async listMessages(folder: string, opts?: { limit?: number; offset?: number }): Promise<EmailEnvelope[]> {
+    const folderId = this.resolveFolderId(folder);
+    const top = opts?.limit || 20;
+    const skip = opts?.offset || 0;
+    const data = await this.graphFetch(
+      `/me/mailFolders/${folderId}/messages?$top=${top}&$skip=${skip}&$select=id,subject,from,toRecipients,receivedDateTime,isRead,flag,hasAttachments,bodyPreview&$orderby=receivedDateTime desc`
+    );
+    return (data.value || []).map((m: any) => this.toEnvelope(m));
+  }
+
+  async readMessage(uid: string): Promise<EmailMessage> {
+    const data = await this.graphFetch(`/me/messages/${uid}?$select=id,subject,from,toRecipients,ccRecipients,bccRecipients,receivedDateTime,isRead,flag,hasAttachments,body,bodyPreview,replyTo,internetMessageId,internetMessageHeaders,conversationId`);
+    return this.toMessage(data);
+  }
+
+  async searchMessages(criteria: SearchCriteria): Promise<EmailEnvelope[]> {
+    const filters: string[] = [];
+    if (criteria.from) filters.push(`from/emailAddress/address eq '${criteria.from}'`);
+    if (criteria.subject) filters.push(`contains(subject, '${criteria.subject}')`);
+    if (criteria.since) filters.push(`receivedDateTime ge ${criteria.since}`);
+    if (criteria.before) filters.push(`receivedDateTime lt ${criteria.before}`);
+    if (criteria.seen !== undefined) filters.push(`isRead eq ${criteria.seen}`);
+
+    let path = '/me/messages?$top=50&$select=id,subject,from,toRecipients,receivedDateTime,isRead,flag,hasAttachments,bodyPreview&$orderby=receivedDateTime desc';
+    if (filters.length) path += '&$filter=' + encodeURIComponent(filters.join(' and '));
+    if (criteria.text) path = `/me/messages?$search="${encodeURIComponent(criteria.text)}"&$top=50&$select=id,subject,from,toRecipients,receivedDateTime,isRead,flag,hasAttachments,bodyPreview`;
+
+    const data = await this.graphFetch(path);
+    return (data.value || []).map((m: any) => this.toEnvelope(m));
+  }
+
+  async listFolders(): Promise<EmailFolder[]> {
+    const data = await this.graphFetch('/me/mailFolders?$select=id,displayName,unreadItemCount,totalItemCount');
+    return (data.value || []).map((f: any) => ({
+      name: f.displayName,
+      path: f.id,
+      unread: f.unreadItemCount || 0,
+      total: f.totalItemCount || 0,
+    }));
+  }
+
+  async createFolder(name: string): Promise<void> {
+    await this.graphFetch('/me/mailFolders', {
+      method: 'POST',
+      body: JSON.stringify({ displayName: name }),
+    });
+  }
+
+  // ─── Send ───────────────────────────────────────────
+
+  async send(options: SendEmailOptions): Promise<{ messageId: string }> {
+    const message = this.buildGraphMessage(options);
+    await this.graphFetch('/me/sendMail', {
+      method: 'POST',
+      body: JSON.stringify({ message, saveToSentItems: true }),
+    });
+    return { messageId: `graph-${Date.now()}` };
+  }
+
+  async reply(uid: string, body: string, replyAll = false): Promise<{ messageId: string }> {
+    const endpoint = replyAll ? 'replyAll' : 'reply';
+    await this.graphFetch(`/me/messages/${uid}/${endpoint}`, {
+      method: 'POST',
+      body: JSON.stringify({ comment: body }),
+    });
+    return { messageId: `graph-reply-${Date.now()}` };
+  }
+
+  async forward(uid: string, to: string, body?: string): Promise<{ messageId: string }> {
+    await this.graphFetch(`/me/messages/${uid}/forward`, {
+      method: 'POST',
+      body: JSON.stringify({
+        comment: body || '',
+        toRecipients: [{ emailAddress: { address: to } }],
+      }),
+    });
+    return { messageId: `graph-fwd-${Date.now()}` };
+  }
+
+  // ─── Organize ───────────────────────────────────────
+
+  async moveMessage(uid: string, toFolder: string): Promise<void> {
+    const folderId = this.resolveFolderId(toFolder);
+    await this.graphFetch(`/me/messages/${uid}/move`, {
+      method: 'POST',
+      body: JSON.stringify({ destinationId: folderId }),
+    });
+  }
+
+  async deleteMessage(uid: string): Promise<void> {
+    await this.graphFetch(`/me/messages/${uid}`, { method: 'DELETE' });
+  }
+
+  async markRead(uid: string): Promise<void> {
+    await this.graphFetch(`/me/messages/${uid}`, {
+      method: 'PATCH',
+      body: JSON.stringify({ isRead: true }),
+    });
+  }
+
+  async markUnread(uid: string): Promise<void> {
+    await this.graphFetch(`/me/messages/${uid}`, {
+      method: 'PATCH',
+      body: JSON.stringify({ isRead: false }),
+    });
+  }
+
+  async flagMessage(uid: string): Promise<void> {
+    await this.graphFetch(`/me/messages/${uid}`, {
+      method: 'PATCH',
+      body: JSON.stringify({ flag: { flagStatus: 'flagged' } }),
+    });
+  }
+
+  async unflagMessage(uid: string): Promise<void> {
+    await this.graphFetch(`/me/messages/${uid}`, {
+      method: 'PATCH',
+      body: JSON.stringify({ flag: { flagStatus: 'notFlagged' } }),
+    });
+  }
+
+  // ─── Batch ──────────────────────────────────────────
+
+  async batchMarkRead(uids: string[]): Promise<void> {
+    await Promise.all(uids.map(uid => this.markRead(uid)));
+  }
+
+  async batchMarkUnread(uids: string[]): Promise<void> {
+    await Promise.all(uids.map(uid => this.markUnread(uid)));
+  }
+
+  async batchMove(uids: string[], toFolder: string): Promise<void> {
+    await Promise.all(uids.map(uid => this.moveMessage(uid, toFolder)));
+  }
+
+  async batchDelete(uids: string[]): Promise<void> {
+    await Promise.all(uids.map(uid => this.deleteMessage(uid)));
+  }
+
+  // ─── Helpers ────────────────────────────────────────
+
+  private resolveFolderId(folder: string): string {
+    const map: Record<string, string> = {
+      INBOX: 'inbox', inbox: 'inbox',
+      Sent: 'sentItems', sent: 'sentItems', sentitems: 'sentItems',
+      Drafts: 'drafts', drafts: 'drafts',
+      Trash: 'deletedItems', trash: 'deletedItems', deleteditems: 'deletedItems',
+      Junk: 'junkemail', junk: 'junkemail', spam: 'junkemail',
+      Archive: 'archive', archive: 'archive',
+    };
+    return map[folder] || folder;
+  }
+
+  private buildGraphMessage(options: SendEmailOptions): any {
+    const msg: any = {
+      subject: options.subject,
+      body: { contentType: options.html ? 'HTML' : 'Text', content: options.html || options.body },
+      toRecipients: options.to.split(',').map(e => ({ emailAddress: { address: e.trim() } })),
+    };
+    if (options.cc) msg.ccRecipients = options.cc.split(',').map(e => ({ emailAddress: { address: e.trim() } }));
+    if (options.bcc) msg.bccRecipients = options.bcc.split(',').map(e => ({ emailAddress: { address: e.trim() } }));
+    if (options.inReplyTo) msg.internetMessageHeaders = [{ name: 'In-Reply-To', value: options.inReplyTo }];
+    return msg;
+  }
+
+  private toEnvelope(m: any): EmailEnvelope {
+    return {
+      uid: m.id,
+      from: { name: m.from?.emailAddress?.name, email: m.from?.emailAddress?.address || '' },
+      to: (m.toRecipients || []).map((r: any) => ({ name: r.emailAddress?.name, email: r.emailAddress?.address || '' })),
+      subject: m.subject || '',
+      date: m.receivedDateTime || '',
+      read: !!m.isRead,
+      flagged: m.flag?.flagStatus === 'flagged',
+      hasAttachments: !!m.hasAttachments,
+      preview: m.bodyPreview || '',
+    };
+  }
+
+  private toMessage(m: any): EmailMessage {
+    return {
+      uid: m.id,
+      from: { name: m.from?.emailAddress?.name, email: m.from?.emailAddress?.address || '' },
+      to: (m.toRecipients || []).map((r: any) => ({ name: r.emailAddress?.name, email: r.emailAddress?.address || '' })),
+      cc: (m.ccRecipients || []).map((r: any) => ({ name: r.emailAddress?.name, email: r.emailAddress?.address || '' })),
+      subject: m.subject || '',
+      body: m.body?.contentType === 'HTML' ? '' : (m.body?.content || ''),
+      html: m.body?.contentType === 'HTML' ? m.body?.content : undefined,
+      date: m.receivedDateTime || '',
+      read: !!m.isRead,
+      flagged: m.flag?.flagStatus === 'flagged',
+      folder: 'inbox',
+      messageId: m.internetMessageId,
+      attachments: [],
+    };
+  }
+}