@masonator/m365-mcp 0.2.0 → 0.5.0

package/dist/__tests__/tools/transcripts.test.js

@@ -8,7 +8,7 @@ jest.unstable_mockModule('../../lib/graph.js', () => ({
 const mockFetch = jest.fn();
 globalThis.fetch = mockFetch;
 // Dynamic import AFTER mocks are registered
-const { executeTranscripts, extractMeetingId, parseTranscriptId } = await import('../../lib/tools/transcripts.js');
+const { executeTranscripts, extractMeetingId, parseTranscriptId, matchTranscriptsToEvent } = await import('../../lib/tools/transcripts.js');
 // ── Helpers ────────────────────────────────────────────────────────────────
 function makeJoinUrl(threadId, oid, tid = 'tenant-123') {
     const context = JSON.stringify({ Tid: tid, Oid: oid });
@@ -113,6 +113,87 @@ describe('parseTranscriptId', () => {
         });
     });
 });
+// ── matchTranscriptsToEvent ────────────────────────────────────────────────
+describe('matchTranscriptsToEvent', () => {
+    it('returns single transcript when close to event', () => {
+        const transcripts = [{ id: 'tx-1', createdDateTime: '2025-06-15T10:02:00Z' }];
+        const event = { start: { dateTime: '2025-06-15T10:00:00' } };
+        const result = matchTranscriptsToEvent(transcripts, event);
+        expect(result).toEqual([{ id: 'tx-1', createdDateTime: '2025-06-15T10:02:00Z' }]);
+    });
+    it('skips single transcript when far from event (recurring meeting, different occurrence)', () => {
+        const transcripts = [{ id: 'tx-1', createdDateTime: '2025-06-15T10:00:00Z' }];
+        // Event is 7 days later — different occurrence of recurring meeting
+        const event = { start: { dateTime: '2025-06-22T10:00:00' } };
+        const result = matchTranscriptsToEvent(transcripts, event);
+        expect(result).toHaveLength(0);
+    });
+    it('returns single transcript without createdDateTime as fallback', () => {
+        const transcripts = [{ id: 'tx-1' }];
+        const event = { start: { dateTime: '2025-06-15T10:00:00' } };
+        const result = matchTranscriptsToEvent(transcripts, event);
+        // No createdDateTime means we can't match — fall back to returning it
+        expect(result).toEqual([{ id: 'tx-1' }]);
+    });
+    it('returns closest transcript when multiple exist', () => {
+        const transcripts = [
+            { id: 'tx-week1', createdDateTime: '2025-06-15T10:02:00Z' },
+            { id: 'tx-week2', createdDateTime: '2025-06-22T10:03:00Z' },
+            { id: 'tx-week3', createdDateTime: '2025-06-29T10:01:00Z' },
+        ];
+        const event = { start: { dateTime: '2025-06-22T10:00:00Z' } };
+        const result = matchTranscriptsToEvent(transcripts, event);
+        expect(result).toEqual([{ id: 'tx-week2', createdDateTime: '2025-06-22T10:03:00Z' }]);
+    });
+    it('returns all transcripts when event has no start time', () => {
+        const transcripts = [
+            { id: 'tx-1', createdDateTime: '2025-06-15T10:00:00Z' },
+            { id: 'tx-2', createdDateTime: '2025-06-22T10:00:00Z' },
+        ];
+        const event = {};
+        const result = matchTranscriptsToEvent(transcripts, event);
+        expect(result).toHaveLength(2);
+    });
+    it('returns all transcripts when no createdDateTime available', () => {
+        const transcripts = [{ id: 'tx-1' }, { id: 'tx-2' }];
+        const event = { start: { dateTime: '2025-06-15T10:00:00' } };
+        const result = matchTranscriptsToEvent(transcripts, event);
+        expect(result).toHaveLength(2);
+    });
+    it('returns empty array for zero transcripts', () => {
+        const event = { start: { dateTime: '2025-06-15T10:00:00' } };
+        const result = matchTranscriptsToEvent([], event);
+        expect(result).toHaveLength(0);
+    });
+    it('ignores transcripts with invalid createdDateTime', () => {
+        const transcripts = [
+            { id: 'tx-bad', createdDateTime: 'not-a-date' },
+            { id: 'tx-good', createdDateTime: '2025-06-15T10:05:00Z' },
+        ];
+        const event = { start: { dateTime: '2025-06-15T10:00:00' } };
+        const result = matchTranscriptsToEvent(transcripts, event);
+        expect(result).toEqual([{ id: 'tx-good', createdDateTime: '2025-06-15T10:05:00Z' }]);
+    });
+    it('returns all when event start dateTime is invalid', () => {
+        const transcripts = [
+            { id: 'tx-1', createdDateTime: '2025-06-15T10:00:00Z' },
+            { id: 'tx-2', createdDateTime: '2025-06-22T10:00:00Z' },
+        ];
+        const event = { start: { dateTime: 'not-a-date' } };
+        const result = matchTranscriptsToEvent(transcripts, event);
+        expect(result).toHaveLength(2);
+    });
+    it('returns empty when closest transcript is beyond 24-hour threshold', () => {
+        const transcripts = [
+            { id: 'tx-1', createdDateTime: '2025-06-15T10:00:00Z' },
+            { id: 'tx-2', createdDateTime: '2025-06-22T10:00:00Z' },
+        ];
+        // Event is 4 days away from nearest transcript
+        const event = { start: { dateTime: '2025-06-19T10:00:00Z' } };
+        const result = matchTranscriptsToEvent(transcripts, event);
+        expect(result).toHaveLength(0);
+    });
+});
 // ── executeTranscripts ─────────────────────────────────────────────────────
 describe('executeTranscripts', () => {
     afterEach(() => {
@@ -121,11 +202,9 @@ describe('executeTranscripts', () => {
     });
     // ── Drill-down mode ──────────────────────────────────────────────────
     describe('drill-down mode', () => {
-        it('returns full transcript for valid compound ID', async () => {
+        it('returns short transcript marked as complete', async () => {
             const vttContent = 'WEBVTT\n\n00:00:00.000 --> 00:00:05.000\nHello world';
-            // VTT content fetch (raw fetch, v1.0 succeeds)
             mockFetch.mockResolvedValueOnce(mockResponse(vttContent));
-            // Meeting subject fetch
             mockGraphFetch.mockResolvedValueOnce({
                 ok: true,
                 data: { subject: 'Team Standup' },
@@ -134,15 +213,77 @@ describe('executeTranscripts', () => {
                 transcript_id: 'meetingId123/transcriptId456',
             });
             expect(result).toContain('# Transcript: Team Standup');
+            expect(result).toContain('(complete)');
             expect(result).toContain(vttContent);
+            expect(result).not.toContain('To continue reading');
+        });
+        it('paginates long transcript with continuation instructions', async () => {
+            const vttContent = 'WEBVTT\n\n' + 'A'.repeat(15000);
+            mockFetch.mockResolvedValueOnce(mockResponse(vttContent));
+            mockGraphFetch.mockResolvedValueOnce({
+                ok: true,
+                data: { subject: 'Long Meeting' },
+            });
+            const result = await executeTranscripts('test-token', {
+                transcript_id: 'meeting123/transcript456',
+            });
+            expect(result).toContain('# Transcript: Long Meeting');
+            expect(result).toContain(`Length: ${vttContent.length} chars`);
+            expect(result).toContain('Showing: 0–10000');
+            expect(result).toContain(`Remaining: ${vttContent.length - 10000}`);
+            expect(result).toContain('To continue reading');
+            expect(result).toContain('offset=10000');
+            // Should not contain the full content
+            expect(result).not.toContain('A'.repeat(15000));
+        });
+        it('returns next chunk when offset is provided', async () => {
+            const vttContent = 'B'.repeat(5000) + 'C'.repeat(5000) + 'D'.repeat(5000);
+            mockFetch.mockResolvedValueOnce(mockResponse(vttContent));
+            mockGraphFetch.mockResolvedValueOnce({
+                ok: true,
+                data: { subject: 'Offset Test' },
+            });
+            const result = await executeTranscripts('test-token', {
+                transcript_id: 'meeting/transcript',
+                offset: 10000,
+            });
+            expect(result).toContain('Showing: 10000–15000');
+            expect(result).toContain('Remaining: 0');
+            expect(result).not.toContain('To continue reading');
+            // Should contain only 'D' content
+            expect(result).toContain('D'.repeat(5000));
+        });
+        it('respects custom length parameter', async () => {
+            const vttContent = 'X'.repeat(30000);
+            mockFetch.mockResolvedValueOnce(mockResponse(vttContent));
+            mockGraphFetch.mockResolvedValueOnce({
+                ok: true,
+                data: { subject: 'Custom Length' },
+            });
+            const result = await executeTranscripts('test-token', {
+                transcript_id: 'meeting/transcript',
+                length: 20000,
+            });
+            expect(result).toContain('Showing: 0–20000');
+            expect(result).toContain('Remaining: 10000');
+        });
+        it('clamps length to max 50000', async () => {
+            const vttContent = 'Y'.repeat(80000);
+            mockFetch.mockResolvedValueOnce(mockResponse(vttContent));
+            mockGraphFetch.mockResolvedValueOnce({
+                ok: true,
+                data: { subject: 'Max Length' },
+            });
+            const result = await executeTranscripts('test-token', {
+                transcript_id: 'meeting/transcript',
+                length: 999999,
+            });
+            expect(result).toContain('Showing: 0–50000');
         });
         it('falls back to beta when v1.0 returns 403', async () => {
             const vttContent = 'WEBVTT\n\nFallback content';
-            // v1.0 returns 403
             mockFetch.mockResolvedValueOnce(mockResponse('Forbidden', 403));
-            // beta returns successfully
             mockFetch.mockResolvedValueOnce(mockResponse(vttContent));
-            // Meeting subject
             mockGraphFetch.mockResolvedValueOnce({
                 ok: true,
                 data: { subject: 'Beta Meeting' },
@@ -183,9 +324,10 @@ describe('executeTranscripts', () => {
             });
             expect(result).toContain('Error: Invalid transcript_id format');
         });
-        it('uses (Unknown meeting) when subject fetch fails', async () => {
+        it('uses (Unknown meeting) when subject fetch fails with non-retryable error', async () => {
             const vttContent = 'WEBVTT\n\nContent here';
             mockFetch.mockResolvedValueOnce(mockResponse(vttContent));
+            // 404 is not retryable — no beta fallback
             mockGraphFetch.mockResolvedValueOnce({
                 ok: false,
                 error: { status: 404, message: 'Not found' },
@@ -196,6 +338,43 @@ describe('executeTranscripts', () => {
             expect(result).toContain('# Transcript: (Unknown meeting)');
             expect(result).toContain(vttContent);
         });
+        it('falls back to beta for meeting subject on 403', async () => {
+            const vttContent = 'WEBVTT\n\nBeta subject content';
+            mockFetch.mockResolvedValueOnce(mockResponse(vttContent));
+            // v1.0 subject fetch fails with 403
+            mockGraphFetch.mockResolvedValueOnce({
+                ok: false,
+                error: { status: 403, message: 'Forbidden' },
+            });
+            // beta subject fetch succeeds
+            mockGraphFetch.mockResolvedValueOnce({
+                ok: true,
+                data: { subject: 'Beta Subject Meeting' },
+            });
+            const result = await executeTranscripts('test-token', {
+                transcript_id: 'meeting/transcript',
+            });
+            expect(result).toContain('# Transcript: Beta Subject Meeting');
+            expect(mockGraphFetch).toHaveBeenCalledWith(expect.stringContaining('onlineMeetings'), 'test-token', { beta: true });
+        });
+        it('shows (Unknown meeting) when both v1.0 and beta subject fetch fail', async () => {
+            const vttContent = 'WEBVTT\n\nContent';
+            mockFetch.mockResolvedValueOnce(mockResponse(vttContent));
+            // v1.0 fails with 400
+            mockGraphFetch.mockResolvedValueOnce({
+                ok: false,
+                error: { status: 400, message: 'Bad request' },
+            });
+            // beta also fails
+            mockGraphFetch.mockResolvedValueOnce({
+                ok: false,
+                error: { status: 400, message: 'Bad request' },
+            });
+            const result = await executeTranscripts('test-token', {
+                transcript_id: 'meeting/transcript',
+            });
+            expect(result).toContain('# Transcript: (Unknown meeting)');
+        });
     });
     // ── List mode ────────────────────────────────────────────────────────
     describe('list mode', () => {
@@ -225,46 +404,14 @@ describe('executeTranscripts', () => {
                 ok: true,
                 data: { value: [{ id: 'transcript-001' }] },
             });
-            // VTT content
-            const vttContent = 'WEBVTT\n\n00:00:00.000 --> 00:00:05.000\nHello from sprint';
-            mockFetch.mockResolvedValueOnce(mockResponse(vttContent));
             const result = await executeTranscripts('test-token', { date: '2025-06-15' });
             expect(result).toContain('Found 1 meetings, 1 with transcripts.');
             expect(result).toContain('## Sprint Planning');
             expect(result).toContain('Date: 2025-06-15T10:00:00');
             expect(result).toContain('Attendees: Alice, Bob');
             expect(result).toContain(`Transcript ID: ${meetingId}/transcript-001`);
-            expect(result).toContain(vttContent);
-        });
-        it('truncates VTT preview to ~3000 chars', async () => {
-            const threadId = '19:meeting_long@thread.v2';
-            const oid = 'oid-long';
-            const joinUrl = makeJoinUrl(threadId, oid);
-            // Calendar view
-            mockGraphFetch.mockResolvedValueOnce({
-                ok: true,
-                data: {
-                    value: [
-                        {
-                            subject: 'Long Meeting',
-                            start: { dateTime: '2025-06-15T10:00:00' },
-                            onlineMeeting: { joinUrl },
-                        },
-                    ],
-                },
-            });
-            // Transcripts list
-            mockGraphFetch.mockResolvedValueOnce({
-                ok: true,
-                data: { value: [{ id: 'tx-long' }] },
-            });
-            // Long VTT content
-            const longVtt = 'WEBVTT\n\n' + 'A'.repeat(4000);
-            mockFetch.mockResolvedValueOnce(mockResponse(longVtt));
-            const result = await executeTranscripts('test-token', { date: '2025-06-15' });
-            expect(result).toContain('... [truncated — use transcript_id for full content]');
-            // The preview should not contain the full 4000-char string
-            expect(result).not.toContain('A'.repeat(4000));
+            // List mode no longer fetches VTT previews — drill-down handles full content
+            expect(mockFetch).not.toHaveBeenCalled();
         });
         it('handles empty calendar (no meetings)', async () => {
             mockGraphFetch.mockResolvedValueOnce({
@@ -358,13 +505,12 @@ describe('executeTranscripts', () => {
                 ok: true,
                 data: { value: [{ id: 'tx-500' }] },
             });
-            // v1.0 VTT fetch returns 500 (non-retryable)
-            mockFetch.mockResolvedValueOnce(mockResponse('Internal Server Error', 500));
             const result = await executeTranscripts('test-token', { date: '2025-06-15' });
-            // Meeting has transcripts but VTT download failed — still shows meeting without preview
+            // Meeting has transcripts — listed without VTT preview
             expect(result).toContain('1 with transcripts');
             expect(result).toContain('Server Error Meeting');
-            expect(mockFetch).toHaveBeenCalledTimes(1); // No beta retry for 500
+            // List mode no longer fetches VTT content
+            expect(mockFetch).not.toHaveBeenCalled();
         });
         it('skips meeting when both v1.0 and beta transcript listing fail with non-retryable error', async () => {
             const threadId = '19:meeting_fail@thread.v2';
@@ -423,8 +569,6 @@ describe('executeTranscripts', () => {
                 ok: true,
                 data: { value: [{ id: 'tx-beta' }] },
             });
-            // VTT content
-            mockFetch.mockResolvedValueOnce(mockResponse('WEBVTT\n\nBeta content'));
             const result = await executeTranscripts('test-token', { date: '2025-06-15' });
             expect(result).toContain('1 with transcripts');
             expect(result).toContain('Beta Transcripts');
@@ -456,13 +600,110 @@ describe('executeTranscripts', () => {
                 ok: true,
                 data: { value: [{ id: 'tx-1' }] },
             });
-            // VTT content
-            mockFetch.mockResolvedValueOnce(mockResponse('WEBVTT\n\nOnline content'));
             const result = await executeTranscripts('test-token', { date: '2025-06-15' });
             // Only 1 meeting (with joinUrl) counted, 1 with transcripts
             expect(result).toContain('Found 1 meetings, 1 with transcripts.');
             expect(result).toContain('Online Meeting');
             expect(result).not.toContain('In-Person Meeting');
         });
+        it('matches correct transcript to each occurrence of a recurring meeting', async () => {
+            const threadId = '19:recurring_standup@thread.v2';
+            const oid = 'organizer-oid';
+            const joinUrl = makeJoinUrl(threadId, oid);
+            const meetingId = Buffer.from(`1*${oid}*0**${threadId}`).toString('base64');
+            // Calendar view returns two occurrences with the SAME join URL
+            mockGraphFetch.mockResolvedValueOnce({
+                ok: true,
+                data: {
+                    value: [
+                        {
+                            subject: 'Weekly Standup',
+                            start: { dateTime: '2025-06-15T10:00:00' },
+                            end: { dateTime: '2025-06-15T10:30:00' },
+                            onlineMeeting: { joinUrl },
+                        },
+                        {
+                            subject: 'Weekly Standup',
+                            start: { dateTime: '2025-06-22T10:00:00' },
+                            end: { dateTime: '2025-06-22T10:30:00' },
+                            onlineMeeting: { joinUrl },
+                        },
+                    ],
+                },
+            });
+            // Transcript list fetched ONCE (cached for second occurrence)
+            mockGraphFetch.mockResolvedValueOnce({
+                ok: true,
+                data: {
+                    value: [
+                        { id: 'tx-week1', createdDateTime: '2025-06-15T10:02:00Z' },
+                        { id: 'tx-week2', createdDateTime: '2025-06-22T10:03:00Z' },
+                    ],
+                },
+            });
+            const result = await executeTranscripts('test-token', {
+                start: '2025-06-14T00:00:00Z',
+                end: '2025-06-23T00:00:00Z',
+            });
+            // Both occurrences found with transcripts
+            expect(result).toContain('2 with transcripts');
+            // Each occurrence has its own distinct transcript ID
+            expect(result).toContain(`${meetingId}/tx-week1`);
+            expect(result).toContain(`${meetingId}/tx-week2`);
+            // List mode no longer fetches VTT content
+            expect(mockFetch).not.toHaveBeenCalled();
+            // Transcript list fetched only once (not twice) — cached for recurring
+            const transcriptCalls = mockGraphFetch.mock.calls.filter((call) => call[0].includes('/transcripts'));
+            expect(transcriptCalls).toHaveLength(1);
+        });
+        it('skips recurring occurrence that has no matching transcript', async () => {
+            const threadId = '19:recurring_weekly@thread.v2';
+            const oid = 'oid-recurring';
+            const joinUrl = makeJoinUrl(threadId, oid);
+            const meetingId = Buffer.from(`1*${oid}*0**${threadId}`).toString('base64');
+            // Three occurrences, but only two have transcripts
+            mockGraphFetch.mockResolvedValueOnce({
+                ok: true,
+                data: {
+                    value: [
+                        {
+                            subject: 'Team Sync',
+                            start: { dateTime: '2025-06-08T14:00:00' },
+                            onlineMeeting: { joinUrl },
+                        },
+                        {
+                            subject: 'Team Sync',
+                            start: { dateTime: '2025-06-15T14:00:00' },
+                            onlineMeeting: { joinUrl },
+                        },
+                        {
+                            subject: 'Team Sync',
+                            start: { dateTime: '2025-06-22T14:00:00' },
+                            onlineMeeting: { joinUrl },
+                        },
+                    ],
+                },
+            });
+            // Only two transcripts exist (meeting on Jun 15 wasn't recorded)
+            mockGraphFetch.mockResolvedValueOnce({
+                ok: true,
+                data: {
+                    value: [
+                        { id: 'tx-jun8', createdDateTime: '2025-06-08T14:01:00Z' },
+                        { id: 'tx-jun22', createdDateTime: '2025-06-22T14:02:00Z' },
+                    ],
+                },
+            });
+            const result = await executeTranscripts('test-token', {
+                start: '2025-06-01T00:00:00Z',
+                end: '2025-06-30T00:00:00Z',
+            });
+            // 3 meetings found, but only 2 have matching transcripts
+            expect(result).toContain('Found 3 meetings, 2 with transcripts.');
+            expect(result).toContain(`${meetingId}/tx-jun8`);
+            expect(result).toContain(`${meetingId}/tx-jun22`);
+            // List mode no longer fetches VTT content
+            expect(mockFetch).not.toHaveBeenCalled();
+        });
     });
 });

package/dist/index.js

@@ -10,6 +10,7 @@ import { mailToolDefinition, executeMail } from './lib/tools/mail.js';
 import { chatToolDefinition, executeChat } from './lib/tools/chat.js';
 import { filesToolDefinition, executeFiles } from './lib/tools/files.js';
 import { transcriptsToolDefinition, executeTranscripts } from './lib/tools/transcripts.js';
+import { serverInfoToolDefinition, executeServerInfo } from './lib/tools/server-info.js';
 // Validate env vars at startup
 try {
     loadAuthConfig();
@@ -23,7 +24,7 @@ catch (error) {
     process.stderr.write('  MS365_MCP_CLIENT_SECRET   - Azure AD client secret (confidential clients only)\n');
     process.exit(1);
 }
-const server = new Server({ name: 'm365-mcp', version: '0.2.0' }, { capabilities: { tools: {} } });
+const server = new Server({ name: 'm365-mcp', version: '0.5.0' }, { capabilities: { tools: {} } });
 server.setRequestHandler(ListToolsRequestSchema, async () => ({
     tools: [
         authStatusToolDefinition,
@@ -33,17 +34,22 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
         chatToolDefinition,
         filesToolDefinition,
         transcriptsToolDefinition,
+        serverInfoToolDefinition,
     ],
 }));
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args = {} } = request.params;
     try {
         const config = loadAuthConfig();
-        // auth_status handles its own auth
+        // Tools that don't require a valid token
         if (name === 'ms_auth_status') {
             const result = await executeAuthStatus(config);
             return { content: [{ type: 'text', text: result }] };
         }
+        if (name === 'ms_server_info') {
+            const result = executeServerInfo();
+            return { content: [{ type: 'text', text: result }] };
+        }
         // All other tools need a valid token
         const token = await getAccessToken(config);
         let result;

package/dist/lib/tools/chat.d.ts

@@ -15,6 +15,11 @@ export declare const chatToolDefinition: {
         };
     };
 };
+/**
+ * Converts Teams HTML message content to plain text.
+ * Handles <br>, <p>, <emoji alt="...">, <at>, <attachment>, and other tags.
+ */
+export declare function stripHtml(html: string): string;
 /**
  * Fetches Teams chats or messages from a specific chat thread and returns
  * a human-readable summary.

package/dist/lib/tools/chat.js

@@ -11,10 +11,24 @@ export const chatToolDefinition = {
     },
 };
 /**
- * Strips HTML tags from a string.
+ * Converts Teams HTML message content to plain text.
+ * Handles <br>, <p>, <emoji alt="...">, <at>, <attachment>, and other tags.
  */
-function stripHtml(html) {
-    return html.replace(/<[^>]*>/g, '').trim();
+export function stripHtml(html) {
+    return html
+        .replace(/<br\s*\/?>/gi, '\n')
+        .replace(/<\/p>/gi, '\n')
+        .replace(/<emoji[^>]*alt="([^"]*)"[^>]*\/?>/gi, '$1')
+        .replace(/<attachment[^>]*>.*?<\/attachment>/gis, '')
+        .replace(/<[^>]*>/g, '')
+        .replace(/&nbsp;/g, ' ')
+        .replace(/&amp;/g, '&')
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&quot;/g, '"')
+        .replace(/&#39;/g, "'")
+        .replace(/\n{3,}/g, '\n\n')
+        .trim();
 }
 /**
  * Formats a chat message into a readable line.
@@ -37,7 +51,8 @@ function formatChatListing(chat) {
     lines.push(`## ${topic}`);
     lines.push(`Type: ${chat.chatType || 'unknown'}`);
     if (chat.lastMessagePreview) {
-        const preview = chat.lastMessagePreview.body?.content || '(no preview)';
+        const rawPreview = chat.lastMessagePreview.body?.content || '(no preview)';
+        const preview = rawPreview === '(no preview)' ? rawPreview : stripHtml(rawPreview);
         const time = chat.lastMessagePreview.createdDateTime
             ? new Date(chat.lastMessagePreview.createdDateTime).toLocaleString()
             : '';

package/dist/lib/tools/mail.d.ts

@@ -12,14 +12,23 @@ export declare const mailToolDefinition: {
                 type: string;
                 description: string;
             };
+            message_id: {
+                type: string;
+                description: string;
+            };
         };
     };
 };
 /**
  * Fetches recent emails from the user's mailbox with optional search filtering
  * and returns a human-readable summary.
+ *
+ * Supports two modes:
+ * - List mode: returns email summaries with previews and message IDs
+ * - Drill-down mode: when message_id is provided, returns the full email body
  */
 export declare function executeMail(token: string, args: {
     search?: string;
     count?: number;
+    message_id?: string;
 }): Promise<string>;