ms365-mcp-server 1.0.3 → 1.0.5

package/README.md

@@ -18,7 +18,7 @@ A powerful **Model Context Protocol (MCP) server** that enables seamless Microso
 ### 📧 Core Email Operations (12 tools)
 - **`send_email`** - Send emails with attachments, HTML/text content, CC/BCC
 - **`read_email`** - Read full email content including headers and attachments  
-- **`search_emails`** - Advanced search with filtering and date ranges
+- **`search_emails`** - Advanced search with intelligent partial name matching
 - **`search_emails_to_me`** - Find emails addressed to YOU (both TO and CC fields)
 - **`list_emails`** - List emails in inbox, sent, or custom folders
 - **`get_attachment`** - Download and retrieve email attachments
@@ -139,10 +139,12 @@ ms365-mcp-server --setup-auth
 
 ### 🔍 Email Search Options
 
-- **`search_emails`** - General search with manual recipient specification
-  - Requires you to specify email addresses in `to` or `cc` fields
-  - More flexible for searching any recipient combinations
-  - Example: `{"to": "someone@company.com", "from": "boss@company.com"}`
+- **`search_emails`** - Unified search with intelligent capabilities
+  - **Smart Name Matching**: Automatically detects names vs email addresses
+  - **Partial Name Support**: Search by "Madan", "Kumar", "M Kumar", etc.
+  - **Flexible Criteria**: Combine name search with date ranges, subjects, etc.
+  - **Email Address Matching**: Use exact email addresses when needed
+  - Example: `{"from": "Madan", "after": "2024-01-01"}` or `{"from": "boss@company.com"}`
 
 - **`search_emails_to_me`** - Automatic search for emails addressed to YOU
   - Automatically uses your email address for both TO and CC searches

package/dist/index.js

@@ -55,7 +55,7 @@ function parseArgs() {
 }
 const server = new Server({
     name: "ms365-mcp-server",
-    version: "1.0.3"
+    version: "1.0.5"
 }, {
     capabilities: {
         resources: {
@@ -197,7 +197,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
         },
         {
             name: "search_emails",
-            description: "Search emails with various criteria including subject, sender, TO/CC recipients, date range, and advanced filtering. Supports complex queries and filtering, including emails addressed to you directly or where you were CC'd.",
+            description: "Search emails with various criteria including subject, sender, TO/CC recipients, date range, and advanced filtering. Features intelligent partial name matching for senders - just use their first name, last name, or partial name in the 'from' field. Supports complex queries and filtering, including emails addressed to you directly or where you were CC'd.",
             inputSchema: {
                 type: "object",
                 properties: {
@@ -770,11 +770,22 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 const isAuthenticated = await enhancedMS365Auth.isAuthenticated();
                 const currentUser = await enhancedMS365Auth.getCurrentUser();
                 const storageInfo = enhancedMS365Auth.getStorageInfo();
+                const tokenInfo = await enhancedMS365Auth.getTokenExpirationInfo();
+                let statusText = `📊 Microsoft 365 Authentication Status\n\n🔐 Authentication: ${isAuthenticated ? '✅ Valid' : '❌ Not authenticated'}\n👤 Current User: ${currentUser || 'None'}\n💾 Storage method: ${storageInfo.method}\n📁 Storage location: ${storageInfo.location}`;
+                if (isAuthenticated) {
+                    statusText += `\n⏰ Token expires in: ${tokenInfo.expiresInMinutes} minutes`;
+                    if (tokenInfo.needsRefresh) {
+                        statusText += `\n⚠️ Token will be refreshed automatically on next operation`;
+                    }
+                }
+                else {
+                    statusText += `\n💡 Use the "authenticate_with_device_code" tool to sign in`;
+                }
                 return {
                     content: [
                         {
                             type: "text",
-                            text: `📊 Microsoft 365 Authentication Status\n\n🔐 Authentication: ${isAuthenticated ? '✅ Valid' : '❌ Not authenticated'}\n👤 Current User: ${currentUser || 'None'}\n💾 Storage method: ${storageInfo.method}\n📁 Storage location: ${storageInfo.location}`
+                            text: statusText
                         }
                     ]
                 };
@@ -881,37 +892,37 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     ms365Ops.setGraphClient(graphClient);
                 }
                 const searchResults = await ms365Ops.searchEmails(args);
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `🔍 Email Search Results (${searchResults.messages.length} found)\n\n${searchResults.messages.map((email, index) => `${index + 1}. 📧 ${email.subject}\n   👤 From: ${email.from.name} <${email.from.address}>\n   📅 ${new Date(email.receivedDateTime).toLocaleDateString()}\n   🆔 ID: ${email.id}\n`).join('\n')}`
-                        }
-                    ]
-                };
-            case "search_emails_to_me":
-                if (ms365Config.multiUser) {
-                    const userId = args?.userId;
-                    if (!userId) {
-                        throw new Error("User ID is required in multi-user mode");
+                // Enhanced feedback for search results
+                let responseText = `🔍 Email Search Results (${searchResults.messages.length} found)`;
+                if (searchResults.messages.length === 0) {
+                    responseText = `🔍 No emails found matching your criteria.\n\n💡 Search Tips:\n`;
+                    if (args?.from) {
+                        responseText += `• Try partial names: "${args.from.split(' ')[0]}" or "${args.from.split(' ').pop()}"\n`;
+                        responseText += `• Check spelling of sender name\n`;
                     }
-                    const graphClient = await multiUserMS365Auth.getGraphClientForUser(userId);
-                    ms365Ops.setGraphClient(graphClient);
+                    if (args?.subject) {
+                        responseText += `• Try broader subject terms\n`;
+                    }
+                    if (args?.after || args?.before) {
+                        responseText += `• Try expanding date range\n`;
+                    }
+                    responseText += `• Remove some search criteria to get broader results`;
                 }
                 else {
-                    const graphClient = await enhancedMS365Auth.getGraphClient();
-                    ms365Ops.setGraphClient(graphClient);
+                    responseText += `\n\n${searchResults.messages.map((email, index) => `${index + 1}. 📧 ${email.subject}\n   👤 From: ${email.from.name} <${email.from.address}>\n   📅 ${new Date(email.receivedDateTime).toLocaleDateString()}\n   ${email.isRead ? '📖 Read' : '📩 Unread'}\n   🆔 ID: ${email.id}\n`).join('\n')}`;
+                    if (searchResults.hasMore) {
+                        responseText += `\n💡 There are more results available. Use maxResults parameter to get more emails.`;
+                    }
                 }
-                const searchToMeResults = await ms365Ops.searchEmailsToMe(args);
                 return {
                     content: [
                         {
                             type: "text",
-                            text: `🔍 Emails Addressed to You (TO & CC) - ${searchToMeResults.messages.length} found\n\n${searchToMeResults.messages.map((email, index) => `${index + 1}. 📧 ${email.subject}\n   👤 From: ${email.from.name} <${email.from.address}>\n   📅 ${new Date(email.receivedDateTime).toLocaleDateString()}\n   🆔 ID: ${email.id}\n`).join('\n')}`
+                            text: responseText
                         }
                     ]
                 };
-            case "list_emails":
+            case "search_emails_to_me":
                 if (ms365Config.multiUser) {
                     const userId = args?.userId;
                     if (!userId) {
@@ -924,12 +935,12 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     const graphClient = await enhancedMS365Auth.getGraphClient();
                     ms365Ops.setGraphClient(graphClient);
                 }
-                const emailList = await ms365Ops.listEmails(args?.folderId, args?.maxResults);
+                const searchToMeResults = await ms365Ops.searchEmailsToMe(args);
                 return {
                     content: [
                         {
                             type: "text",
-                            text: `📬 Email List (${emailList.messages.length} emails)\n\n${emailList.messages.map((email, index) => `${index + 1}. 📧 ${email.subject}\n   👤 From: ${email.from.name} <${email.from.address}>\n   📅 ${new Date(email.receivedDateTime).toLocaleDateString()}\n   ${email.isRead ? '📖' : '📩'} ${email.isRead ? 'Read' : 'Unread'}\n   🆔 ID: ${email.id}\n`).join('\n')}`
+                            text: `🔍 Emails Addressed to You (TO & CC) - ${searchToMeResults.messages.length} found\n\n${searchToMeResults.messages.map((email, index) => `${index + 1}. 📧 ${email.subject}\n   👤 From: ${email.from.name} <${email.from.address}>\n   📅 ${new Date(email.receivedDateTime).toLocaleDateString()}\n   🆔 ID: ${email.id}\n`).join('\n')}`
                         }
                     ]
                 };
@@ -1087,6 +1098,28 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         }
                     ]
                 };
+            case "list_emails":
+                if (ms365Config.multiUser) {
+                    const userId = args?.userId;
+                    if (!userId) {
+                        throw new Error("User ID is required in multi-user mode");
+                    }
+                    const graphClient = await multiUserMS365Auth.getGraphClientForUser(userId);
+                    ms365Ops.setGraphClient(graphClient);
+                }
+                else {
+                    const graphClient = await enhancedMS365Auth.getGraphClient();
+                    ms365Ops.setGraphClient(graphClient);
+                }
+                const emailList = await ms365Ops.listEmails(args?.folderId, args?.maxResults);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `📬 Email List (${emailList.messages.length} emails)\n\n${emailList.messages.map((email, index) => `${index + 1}. 📧 ${email.subject}\n   👤 From: ${email.from.name} <${email.from.address}>\n   📅 ${new Date(email.receivedDateTime).toLocaleDateString()}\n   ${email.isRead ? '📖' : '📩'} ${email.isRead ? 'Read' : 'Unread'}\n   🆔 ID: ${email.id}\n`).join('\n')}`
+                        }
+                    ]
+                };
             default:
                 throw new Error(`Unknown tool: ${name}`);
         }

package/dist/utils/ms365-auth-enhanced.js

@@ -347,12 +347,52 @@ export class EnhancedMS365Auth {
         return client;
     }
     /**
-     * Refresh access token
+     * Get token expiration information for proactive refresh
+     */
+    async getTokenExpirationInfo() {
+        try {
+            const storedToken = await this.loadStoredToken();
+            if (!storedToken) {
+                return { expiresInMinutes: 0, needsRefresh: true };
+            }
+            const now = Date.now();
+            const expiresInMs = storedToken.expiresOn - now;
+            const expiresInMinutes = Math.floor(expiresInMs / (1000 * 60));
+            return {
+                expiresInMinutes: Math.max(0, expiresInMinutes),
+                needsRefresh: expiresInMinutes < 5 // Refresh if expiring within 5 minutes
+            };
+        }
+        catch (error) {
+            logger.error('Error getting token expiration info:', error);
+            return { expiresInMinutes: 0, needsRefresh: true };
+        }
+    }
+    /**
+     * Refresh token if needed (proactive refresh)
+     */
+    async refreshTokenIfNeeded() {
+        try {
+            const tokenInfo = await this.getTokenExpirationInfo();
+            if (tokenInfo.needsRefresh) {
+                logger.log('Proactively refreshing token to prevent interruption...');
+                await this.refreshToken();
+                return true;
+            }
+            return false;
+        }
+        catch (error) {
+            logger.error('Proactive token refresh failed:', error);
+            return false;
+        }
+    }
+    /**
+     * Enhanced refresh token with better error handling
      */
     async refreshToken() {
         const storedToken = await this.loadStoredToken();
         if (!storedToken?.account) {
-            throw new Error('No account information available. Please re-authenticate.');
+            throw new Error('No account information available. Please re-authenticate using: authenticate_with_device_code');
         }
         if (!await this.loadCredentials()) {
             throw new Error('MS365 credentials not configured');
@@ -364,14 +404,23 @@ export class EnhancedMS365Auth {
                 account: storedToken.account
             });
             if (!tokenResponse) {
-                throw new Error('Failed to refresh token');
+                throw new Error('Failed to refresh token - please re-authenticate using: authenticate_with_device_code');
             }
             await this.saveToken(tokenResponse, storedToken.authType);
             logger.log('MS365 token refreshed successfully');
         }
         catch (error) {
-            logger.error('Token refresh failed:', error);
-            throw error;
+            // Enhanced error handling with user-friendly messages
+            if (error.errorCode === 'invalid_grant' || error.errorCode === 'interaction_required') {
+                throw new Error('Authentication has expired. Please re-authenticate using the "authenticate_with_device_code" tool.');
+            }
+            else if (error.errorCode === 'consent_required') {
+                throw new Error('Additional consent required. Please re-authenticate using the "authenticate_with_device_code" tool.');
+            }
+            else {
+                logger.error('Token refresh failed:', error);
+                throw new Error(`Token refresh failed: ${error.message}. Please re-authenticate using the "authenticate_with_device_code" tool.`);
+            }
         }
     }
     /**

package/dist/utils/ms365-operations.js

@@ -1,4 +1,3 @@
-import { ms365Auth } from './ms365-auth.js';
 import { logger } from './api.js';
 /**
  * Microsoft 365 operations manager class
@@ -6,6 +5,38 @@ import { logger } from './api.js';
 export class MS365Operations {
     constructor() {
         this.graphClient = null;
+        this.searchCache = new Map();
+        this.CACHE_DURATION = 60 * 1000; // 1 minute cache
+        this.MAX_RETRIES = 3;
+        this.BASE_DELAY = 1000; // 1 second
+    }
+    /**
+     * Execute API call with retry logic and exponential backoff
+     */
+    async executeWithRetry(operation, context = 'API call') {
+        let lastError;
+        for (let attempt = 1; attempt <= this.MAX_RETRIES; attempt++) {
+            try {
+                return await operation();
+            }
+            catch (error) {
+                lastError = error;
+                // Don't retry on authentication errors or client errors (4xx)
+                if (error.code === 'InvalidAuthenticationToken' ||
+                    (error.status >= 400 && error.status < 500)) {
+                    throw error;
+                }
+                if (attempt === this.MAX_RETRIES) {
+                    logger.error(`${context} failed after ${this.MAX_RETRIES} attempts:`, error);
+                    throw error;
+                }
+                // Exponential backoff with jitter
+                const delay = this.BASE_DELAY * Math.pow(2, attempt - 1) + Math.random() * 1000;
+                logger.log(`${context} failed (attempt ${attempt}), retrying in ${delay}ms...`);
+                await new Promise(resolve => setTimeout(resolve, delay));
+            }
+        }
+        throw lastError;
     }
     /**
      * Set the Microsoft Graph client externally
@@ -14,14 +45,52 @@ export class MS365Operations {
         this.graphClient = client;
     }
     /**
-     * Get authenticated Microsoft Graph client
+     * Get authenticated Microsoft Graph client with proactive token refresh
      */
     async getGraphClient() {
         if (!this.graphClient) {
-            this.graphClient = await ms365Auth.getGraphClient();
+            // Import the enhanced auth module dynamically to avoid circular imports
+            const { enhancedMS365Auth } = await import('./ms365-auth-enhanced.js');
+            // Proactive token check - refresh if expiring within 5 minutes
+            const tokenInfo = await enhancedMS365Auth.getTokenExpirationInfo();
+            if (tokenInfo.expiresInMinutes < 5) {
+                logger.log(`Token expires in ${tokenInfo.expiresInMinutes} minutes, refreshing proactively...`);
+                await enhancedMS365Auth.refreshTokenIfNeeded();
+            }
+            this.graphClient = await enhancedMS365Auth.getGraphClient();
         }
         return this.graphClient;
     }
+    /**
+     * Clear expired cache entries
+     */
+    clearExpiredCache() {
+        const now = Date.now();
+        for (const [key, value] of this.searchCache.entries()) {
+            if (now - value.timestamp > this.CACHE_DURATION) {
+                this.searchCache.delete(key);
+            }
+        }
+    }
+    /**
+     * Get cached search results if available and not expired
+     */
+    getCachedResults(cacheKey) {
+        this.clearExpiredCache();
+        const cached = this.searchCache.get(cacheKey);
+        if (cached && Date.now() - cached.timestamp < this.CACHE_DURATION) {
+            logger.log(`Cache hit for search: ${cacheKey}`);
+            return cached.results;
+        }
+        return null;
+    }
+    /**
+     * Cache search results
+     */
+    setCachedResults(cacheKey, results) {
+        this.searchCache.set(cacheKey, { results, timestamp: Date.now() });
+        logger.log(`Cached results for search: ${cacheKey}`);
+    }
     /**
      * Build filter query for Microsoft Graph API
      */
@@ -65,7 +134,20 @@ export class MS365Operations {
         // Build email-specific search terms using proper Microsoft Graph syntax
         const emailSearchTerms = [];
         if (criteria.from) {
-            emailSearchTerms.push(`from:${criteria.from}`);
+            // Check if it looks like an email address for exact matching
+            if (criteria.from.includes('@')) {
+                emailSearchTerms.push(`from:${criteria.from}`);
+            }
+            else {
+                // For names, use general search which is more flexible with partial matching
+                // This will trigger manual filtering which supports partial names better
+                if (criteria.query) {
+                    searchTerms.push(`${criteria.query} AND ${criteria.from}`);
+                }
+                else {
+                    searchTerms.push(criteria.from);
+                }
+            }
         }
         if (criteria.to) {
             emailSearchTerms.push(`to:${criteria.to}`);
@@ -222,9 +304,64 @@ export class MS365Operations {
      * Search emails with criteria
      */
     async searchEmails(criteria = {}) {
-        try {
+        return await this.executeWithAuth(async () => {
             const graphClient = await this.getGraphClient();
-            // Build search and filter queries
+            // Create cache key from criteria
+            const cacheKey = JSON.stringify(criteria);
+            const cachedResults = this.getCachedResults(cacheKey);
+            if (cachedResults) {
+                return cachedResults;
+            }
+            // For name-based searches, use enhanced approach for better partial matching
+            if (criteria.from && !criteria.from.includes('@')) {
+                logger.log(`Using enhanced name matching for: "${criteria.from}"`);
+                // Get more emails and filter manually for better name matching
+                const maxResults = criteria.maxResults || 100;
+                try {
+                    // Optimized field selection for name search - only get essential fields first
+                    const essentialFields = 'id,subject,from,receivedDateTime,isRead,hasAttachments,importance';
+                    const apiCall = graphClient.api('/me/messages')
+                        .select(essentialFields)
+                        .orderby('receivedDateTime desc')
+                        .top(Math.min(maxResults * 3, 300)); // Get more emails for better filtering
+                    const result = await apiCall.get();
+                    // First pass: filter by name using minimal data
+                    const nameMatches = result.value?.filter((email) => {
+                        const fromName = email.from?.emailAddress?.name?.toLowerCase() || '';
+                        const fromAddress = email.from?.emailAddress?.address?.toLowerCase() || '';
+                        const searchTerm = criteria.from.toLowerCase().trim();
+                        // Quick name matching (subset of the full logic for performance)
+                        return fromName.includes(searchTerm) ||
+                            fromAddress.includes(searchTerm) ||
+                            fromName.split(/\s+/).some((part) => part.startsWith(searchTerm)) ||
+                            searchTerm.split(/\s+/).every((part) => fromName.includes(part));
+                    }) || [];
+                    if (nameMatches.length === 0) {
+                        const emptyResult = { messages: [], hasMore: false };
+                        this.setCachedResults(cacheKey, emptyResult);
+                        return emptyResult;
+                    }
+                    // Second pass: get full details for matched emails
+                    const messageIds = nameMatches.slice(0, maxResults).map((email) => email.id);
+                    const fullMessages = await this.getEmailsByIds(messageIds);
+                    // Apply remaining criteria filtering
+                    let messages = this.applyManualFiltering(fullMessages, criteria);
+                    // Apply maxResults limit
+                    const limitedMessages = messages.slice(0, maxResults);
+                    logger.log(`Enhanced name search found ${limitedMessages.length} emails matching "${criteria.from}"`);
+                    const result_final = {
+                        messages: limitedMessages,
+                        hasMore: messages.length > maxResults || nameMatches.length > maxResults
+                    };
+                    this.setCachedResults(cacheKey, result_final);
+                    return result_final;
+                }
+                catch (error) {
+                    logger.error('Error in enhanced name search, falling back to standard search:', error);
+                    // Fall through to standard search logic
+                }
+            }
+            // Standard search logic (for email addresses and other criteria)
             const searchQuery = this.buildSearchQuery(criteria);
             const filterQuery = this.buildFilterQuery(criteria);
             // Debug logging
@@ -310,10 +447,12 @@ export class MS365Operations {
                 if (useSearchAPI && (criteria.folder || filterQuery)) {
                     messages = this.applyManualFiltering(messages, criteria);
                 }
-                return {
+                const standardResult = {
                     messages,
                     hasMore: !!result['@odata.nextLink']
                 };
+                this.setCachedResults(cacheKey, standardResult);
+                return standardResult;
             }
             catch (searchError) {
                 // If search API fails due to syntax error, fall back to filter-only approach
@@ -366,21 +505,19 @@ export class MS365Operations {
                     // Apply manual filtering for any criteria that couldn't be handled by the filter
                     // This includes subject, to, cc, and query filters that need manual processing
                     messages = this.applyManualFiltering(messages, criteria);
-                    return {
+                    const fallbackResult = {
                         messages,
                         hasMore: !!result['@odata.nextLink']
                     };
+                    this.setCachedResults(cacheKey, fallbackResult);
+                    return fallbackResult;
                 }
                 else {
                     // Re-throw other errors
                     throw searchError;
                 }
             }
-        }
-        catch (error) {
-            logger.error('Error searching emails:', error);
-            throw error;
-        }
+        }, 'searchEmails');
     }
     /**
      * Apply manual filtering to search results (used when $filter can't be used with $search)
@@ -395,9 +532,29 @@ export class MS365Operations {
                     return false;
             }
             if (criteria.from) {
-                const fromMatch = message.from.address.toLowerCase().includes(criteria.from.toLowerCase()) ||
-                    message.from.name.toLowerCase().includes(criteria.from.toLowerCase());
-                if (!fromMatch)
+                const searchTerm = criteria.from.toLowerCase().trim();
+                const fromName = message.from.name.toLowerCase();
+                const fromAddress = message.from.address.toLowerCase();
+                // Multiple matching strategies for better partial name support
+                const matches = [
+                    // Direct name or email match
+                    fromName.includes(searchTerm),
+                    fromAddress.includes(searchTerm),
+                    // Split search term and check if all parts exist in name
+                    searchTerm.split(/\s+/).every(part => fromName.includes(part)),
+                    // Check if any word in the name starts with the search term
+                    fromName.split(/\s+/).some(namePart => namePart.startsWith(searchTerm)),
+                    // Check if search term matches any word in the name exactly
+                    fromName.split(/\s+/).some(namePart => namePart === searchTerm),
+                    // Handle "Last, First" format
+                    fromName.replace(/,\s*/g, ' ').includes(searchTerm),
+                    // Handle initials (e.g., "M Kumar" for "Madan Kumar")
+                    searchTerm.split(/\s+/).length === 2 &&
+                        fromName.split(/\s+/).length >= 2 &&
+                        fromName.split(/\s+/)[0].startsWith(searchTerm.split(/\s+/)[0][0]) &&
+                        fromName.includes(searchTerm.split(/\s+/)[1])
+                ];
+                if (!matches.some(match => match))
                     return false;
             }
             if (criteria.to) {
@@ -706,5 +863,90 @@ export class MS365Operations {
             throw error;
         }
     }
+    /**
+     * Get multiple emails by their IDs efficiently
+     */
+    async getEmailsByIds(messageIds) {
+        try {
+            const graphClient = await this.getGraphClient();
+            // Batch request for better performance when getting multiple emails
+            const emails = [];
+            // Process in batches of 20 to stay within Graph API limits
+            const batchSize = 20;
+            for (let i = 0; i < messageIds.length; i += batchSize) {
+                const batch = messageIds.slice(i, i + batchSize);
+                // Get full details for this batch
+                const promises = batch.map(id => graphClient
+                    .api(`/me/messages/${id}`)
+                    .select('id,subject,from,toRecipients,ccRecipients,receivedDateTime,sentDateTime,bodyPreview,isRead,hasAttachments,importance,conversationId,parentFolderId,webLink')
+                    .get());
+                const results = await Promise.all(promises);
+                const batchEmails = results.map((email) => ({
+                    id: email.id,
+                    subject: email.subject || '',
+                    from: {
+                        name: email.from?.emailAddress?.name || '',
+                        address: email.from?.emailAddress?.address || ''
+                    },
+                    toRecipients: email.toRecipients?.map((recipient) => ({
+                        name: recipient.emailAddress?.name || '',
+                        address: recipient.emailAddress?.address || ''
+                    })) || [],
+                    ccRecipients: email.ccRecipients?.map((recipient) => ({
+                        name: recipient.emailAddress?.name || '',
+                        address: recipient.emailAddress?.address || ''
+                    })) || [],
+                    receivedDateTime: email.receivedDateTime,
+                    sentDateTime: email.sentDateTime,
+                    bodyPreview: email.bodyPreview || '',
+                    isRead: email.isRead || false,
+                    hasAttachments: email.hasAttachments || false,
+                    importance: email.importance || 'normal',
+                    conversationId: email.conversationId || '',
+                    parentFolderId: email.parentFolderId || '',
+                    webLink: email.webLink || ''
+                }));
+                emails.push(...batchEmails);
+            }
+            return emails;
+        }
+        catch (error) {
+            logger.error('Error getting emails by IDs:', error);
+            throw error;
+        }
+    }
+    /**
+     * Clear cached graph client (used when authentication fails)
+     */
+    clearGraphClient() {
+        this.graphClient = null;
+        logger.log('Cleared cached graph client due to authentication failure');
+    }
+    /**
+     * Execute operation with authentication retry
+     */
+    async executeWithAuth(operation, operationName) {
+        try {
+            return await this.executeWithRetry(operation, operationName);
+        }
+        catch (error) {
+            // Check if it's an authentication error
+            if (error.code === 'InvalidAuthenticationToken' ||
+                error.code === 'Unauthorized' ||
+                error.status === 401) {
+                logger.log(`Authentication failed for ${operationName}, clearing cache and retrying...`);
+                this.clearGraphClient();
+                // Retry once with fresh authentication
+                try {
+                    return await this.executeWithRetry(operation, `${operationName} (retry after auth failure)`);
+                }
+                catch (retryError) {
+                    logger.error(`${operationName} failed even after authentication retry:`, retryError);
+                    throw new Error(`Authentication failed. Please re-authenticate using the "authenticate_with_device_code" tool. Details: ${retryError.message}`);
+                }
+            }
+            throw error;
+        }
+    }
 }
 export const ms365Operations = new MS365Operations();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ms365-mcp-server",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "Microsoft 365 MCP Server for managing Microsoft 365 email through natural language interactions with full OAuth2 authentication support",
   "main": "dist/index.js",
   "type": "module",