ms365-mcp-server 1.1.1 → 1.1.3

package/dist/index.js

@@ -55,7 +55,7 @@ function parseArgs() {
 }
 const server = new Server({
     name: "ms365-mcp-server",
-    version: "1.1.1"
+    version: "1.1.3"
 }, {
     capabilities: {
         resources: {
@@ -612,11 +612,32 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                             throw new Error("messageId is required for read action");
                         }
                         const email = await ms365Ops.getEmail(args.messageId, args?.includeAttachments);
+                        let emailDetailsText = `📧 Email Details\n\n📋 Subject: ${email.subject}\n👤 From: ${email.from.name} <${email.from.address}>\n📅 Date: ${email.receivedDateTime}\n`;
+                        if (email.attachments && email.attachments.length > 0) {
+                            emailDetailsText += `\n📎 Attachments (${email.attachments.length}):\n`;
+                            email.attachments.forEach((attachment, index) => {
+                                const sizeInMB = (attachment.size / (1024 * 1024)).toFixed(2);
+                                emailDetailsText += `\n${index + 1}. ${attachment.name}\n`;
+                                emailDetailsText += `   📦 Size: ${sizeInMB} MB\n`;
+                                emailDetailsText += `   📄 Type: ${attachment.contentType}\n`;
+                                emailDetailsText += `   🆔 ID: ${attachment.id}\n`;
+                                if (attachment.isInline) {
+                                    emailDetailsText += `   📌 Inline: Yes\n`;
+                                }
+                            });
+                            emailDetailsText += `\n💡 To download an attachment, use the get_attachment tool with:\n`;
+                            emailDetailsText += `   • messageId: ${email.id}\n`;
+                            emailDetailsText += `   • attachmentId: (use the ID from above)\n`;
+                        }
+                        else {
+                            emailDetailsText += `\n📎 No attachments`;
+                        }
+                        emailDetailsText += `\n\n💬 Body:\n${email.body || email.bodyPreview}`;
                         return {
                             content: [
                                 {
                                     type: "text",
-                                    text: `📧 Email Details\n\n📋 Subject: ${email.subject}\n👤 From: ${email.from.name} <${email.from.address}>\n📅 Date: ${email.receivedDateTime}\n📎 Attachments: ${email.attachments?.length || 0}\n\n💬 Body:\n${email.body || email.bodyPreview}`
+                                    text: emailDetailsText
                                 }
                             ]
                         };
@@ -814,15 +835,44 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     const graphClient = await enhancedMS365Auth.getGraphClient();
                     ms365Ops.setGraphClient(graphClient);
                 }
-                const attachment = await ms365Ops.getAttachment(args?.messageId, args?.attachmentId);
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `📎 Attachment Downloaded\n\n📁 Name: ${attachment.name}\n💾 Size: ${attachment.size} bytes\n🗂️ Type: ${attachment.contentType}\n\n📄 Content available in base64 format`
-                        }
-                    ]
-                };
+                if (!args?.messageId || !args?.attachmentId) {
+                    throw new Error("Both messageId and attachmentId are required");
+                }
+                try {
+                    // First verify the email exists and has attachments
+                    const email = await ms365Ops.getEmail(args.messageId, true);
+                    if (!email.hasAttachments) {
+                        throw new Error("This email has no attachments");
+                    }
+                    if (!email.attachments || email.attachments.length === 0) {
+                        throw new Error("No attachment information available for this email");
+                    }
+                    // Verify the requested attachment exists
+                    const attachmentExists = email.attachments.some(att => att.id === args.attachmentId);
+                    if (!attachmentExists) {
+                        throw new Error(`Attachment ID ${args.attachmentId} not found in this email. Available attachments:\n${email.attachments.map(att => `- ${att.name} (ID: ${att.id})`).join('\n')}`);
+                    }
+                    // Now get the attachment
+                    const attachment = await ms365Ops.getAttachment(args.messageId, args.attachmentId);
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `📎 Attachment Downloaded\n\n📁 Name: ${attachment.name}\n💾 Size: ${attachment.size} bytes\n🗂️ Type: ${attachment.contentType}\n\nBelow is the base64-encoded content. You can save this to a file using a script or tool that decodes base64.\n\n---BASE64 START---\n${attachment.contentBytes}\n---BASE64 END---`
+                            }
+                        ],
+                        base64Content: attachment.contentBytes,
+                        filename: attachment.name,
+                        contentType: attachment.contentType,
+                        size: attachment.size
+                    };
+                }
+                catch (error) {
+                    if (error.message.includes("not found in the store")) {
+                        throw new Error(`Email or attachment not found. Please verify:\n1. The email ID is correct\n2. The attachment ID is correct\n3. You have permission to access this email/attachment`);
+                    }
+                    throw error;
+                }
             case "list_folders":
                 if (ms365Config.multiUser) {
                     const userId = args?.userId;

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

@@ -24,6 +24,7 @@ const DEFAULT_TENANT_ID = "common";
 const CONFIG_DIR = path.join(os.homedir(), '.ms365-mcp');
 const CREDENTIALS_FILE = path.join(CONFIG_DIR, 'credentials.json');
 const DEVICE_CODE_FILE = path.join(CONFIG_DIR, 'device-code.json');
+const TOKEN_CACHE_FILE = path.join(CONFIG_DIR, 'msal-cache.json');
 /**
  * Enhanced Microsoft 365 authentication manager with device code flow support
  */
@@ -97,13 +98,42 @@ export class EnhancedMS365Auth {
         }
     }
     /**
-     * Initialize MSAL client based on auth type
+     * Initialize MSAL client based on auth type with persistent token cache
      */
     initializeMsalClient() {
         if (!this.credentials) {
             throw new Error('Credentials not loaded');
         }
+        // Return existing client if already initialized with same credentials
+        if (this.msalClient) {
+            return this.msalClient;
+        }
         const isConfidential = this.credentials.clientSecret && this.credentials.authType === 'redirect';
+        // Create persistent token cache
+        const cachePlugin = {
+            beforeCacheAccess: async (cacheContext) => {
+                try {
+                    if (fs.existsSync(TOKEN_CACHE_FILE)) {
+                        const cacheData = fs.readFileSync(TOKEN_CACHE_FILE, 'utf8');
+                        cacheContext.tokenCache.deserialize(cacheData);
+                    }
+                }
+                catch (error) {
+                    logger.error('Error loading MSAL token cache:', error);
+                }
+            },
+            afterCacheAccess: async (cacheContext) => {
+                try {
+                    if (cacheContext.cacheHasChanged) {
+                        const cacheData = cacheContext.tokenCache.serialize();
+                        fs.writeFileSync(TOKEN_CACHE_FILE, cacheData);
+                    }
+                }
+                catch (error) {
+                    logger.error('Error saving MSAL token cache:', error);
+                }
+            }
+        };
         if (isConfidential) {
             // Confidential client for redirect-based auth
             const config = {
@@ -112,6 +142,9 @@ export class EnhancedMS365Auth {
                     clientSecret: this.credentials.clientSecret,
                     authority: `https://login.microsoftonline.com/${this.credentials.tenantId}`
                 },
+                cache: {
+                    cachePlugin
+                },
                 system: {
                     loggerOptions: {
                         loggerCallback: (level, message, containsPii) => {
@@ -133,6 +166,9 @@ export class EnhancedMS365Auth {
                     clientId: this.credentials.clientId,
                     authority: `https://login.microsoftonline.com/${this.credentials.tenantId}`
                 },
+                cache: {
+                    cachePlugin
+                },
                 system: {
                     loggerOptions: {
                         loggerCallback: (level, message, containsPii) => {
@@ -147,6 +183,7 @@ export class EnhancedMS365Auth {
             };
             this.msalClient = new PublicClientApplication(config);
         }
+        logger.log('Initialized MSAL client with persistent token cache');
         return this.msalClient;
     }
     /**
@@ -266,14 +303,14 @@ export class EnhancedMS365Auth {
         try {
             const tokenData = {
                 accessToken: token.accessToken,
-                refreshToken: '',
+                refreshToken: '', // MSAL manages refresh tokens internally
                 expiresOn: token.expiresOn?.getTime() || 0,
                 account: token.account,
                 authType: authType
             };
             // Always use a single account key for simplicity
             await credentialStore.setCredentials('ms365-user', tokenData);
-            logger.log('Saved MS365 access token securely');
+            logger.log(`Saved MS365 access token securely (expires: ${new Date(tokenData.expiresOn).toLocaleString()})`);
         }
         catch (error) {
             logger.error('Error saving token:', error);
@@ -331,13 +368,19 @@ export class EnhancedMS365Auth {
      * Get authenticated Microsoft Graph client
      */
     async getGraphClient() {
-        const storedToken = await this.loadStoredToken();
+        let storedToken = await this.loadStoredToken();
         if (!storedToken) {
             throw new Error('No stored token found. Please authenticate first.');
         }
         // Check if token is expired
         if (storedToken.expiresOn < Date.now()) {
+            logger.log('Access token expired, refreshing...');
             await this.refreshToken();
+            // Reload the token after refresh
+            storedToken = await this.loadStoredToken();
+            if (!storedToken) {
+                throw new Error('Failed to refresh token. Please re-authenticate.');
+            }
         }
         const client = Client.init({
             authProvider: (done) => {
@@ -399,9 +442,23 @@ export class EnhancedMS365Auth {
         }
         const msalClient = this.initializeMsalClient();
         try {
+            // Try to get all accounts from MSAL cache first (only available on PublicClientApplication)
+            let accountToUse = storedToken.account;
+            if (msalClient instanceof PublicClientApplication) {
+                const accounts = await msalClient.getAllAccounts();
+                // If we have accounts in MSAL cache, use the first one that matches
+                if (accounts.length > 0) {
+                    const matchingAccount = accounts.find((acc) => acc.username === storedToken.account?.username ||
+                        acc.homeAccountId === storedToken.account?.homeAccountId);
+                    if (matchingAccount) {
+                        accountToUse = matchingAccount;
+                        logger.log('Using account from MSAL cache for token refresh');
+                    }
+                }
+            }
             const tokenResponse = await msalClient.acquireTokenSilent({
                 scopes: SCOPES,
-                account: storedToken.account
+                account: accountToUse
             });
             if (!tokenResponse) {
                 throw new Error('Failed to refresh token - please re-authenticate using: authenticate_with_device_code');
@@ -417,6 +474,9 @@ export class EnhancedMS365Auth {
             else if (error.errorCode === 'consent_required') {
                 throw new Error('Additional consent required. Please re-authenticate using the "authenticate_with_device_code" tool.');
             }
+            else if (error.errorCode === 'no_account_in_silent_request') {
+                throw new Error('No account found in token cache. 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.`);
@@ -457,6 +517,13 @@ export class EnhancedMS365Auth {
         try {
             await credentialStore.deleteCredentials('ms365-user');
             await this.clearDeviceCodeState();
+            // Clear MSAL token cache
+            if (fs.existsSync(TOKEN_CACHE_FILE)) {
+                fs.unlinkSync(TOKEN_CACHE_FILE);
+                logger.log('Cleared MSAL token cache');
+            }
+            // Reset MSAL client instance to force re-initialization
+            this.msalClient = null;
             logger.log('Cleared stored authentication tokens');
         }
         catch (error) {

package/dist/utils/ms365-operations.js

@@ -318,14 +318,16 @@ export class MS365Operations {
     async getEmail(messageId, includeAttachments = false) {
         try {
             const graphClient = await this.getGraphClient();
-            let selectFields = 'id,subject,from,toRecipients,ccRecipients,receivedDateTime,sentDateTime,bodyPreview,isRead,hasAttachments,importance,conversationId,parentFolderId,webLink';
-            if (includeAttachments) {
-                selectFields += ',body';
-            }
+            logger.log('Fetching email details...');
+            // First get the basic email info with attachments expanded
             const email = await graphClient
                 .api(`/me/messages/${messageId}`)
-                .select(selectFields)
+                .select('id,subject,from,toRecipients,ccRecipients,receivedDateTime,sentDateTime,bodyPreview,isRead,hasAttachments,importance,conversationId,parentFolderId,webLink,body,attachments')
+                .expand('attachments')
                 .get();
+            logger.log(`Email details retrieved. hasAttachments flag: ${email.hasAttachments}`);
+            logger.log(`Email subject: ${email.subject}`);
+            logger.log(`Direct attachments count: ${email.attachments?.length || 0}`);
             const emailInfo = {
                 id: email.id,
                 subject: email.subject || '',
@@ -349,22 +351,75 @@ export class MS365Operations {
                 importance: email.importance || 'normal',
                 conversationId: email.conversationId || '',
                 parentFolderId: email.parentFolderId || '',
-                webLink: email.webLink || ''
+                webLink: email.webLink || '',
+                attachments: email.attachments?.map((attachment) => ({
+                    id: attachment.id,
+                    name: attachment.name,
+                    contentType: attachment.contentType,
+                    size: attachment.size,
+                    isInline: attachment.isInline,
+                    contentId: attachment.contentId
+                })) || []
             };
-            if (includeAttachments && email.body) {
+            if (email.body) {
                 emailInfo.body = email.body.content || '';
             }
-            // Get attachments if requested
-            if (includeAttachments && email.hasAttachments) {
-                const attachments = await graphClient
-                    .api(`/me/messages/${messageId}/attachments`)
-                    .get();
-                emailInfo.attachments = attachments.value || [];
+            // Always try to get attachments if requested
+            if (includeAttachments) {
+                logger.log('Attempting to fetch attachments...');
+                try {
+                    // First check if we got attachments from the expanded query
+                    if (email.attachments && email.attachments.length > 0) {
+                        logger.log(`Found ${email.attachments.length} attachments from expanded query`);
+                        emailInfo.attachments = email.attachments.map((attachment) => ({
+                            id: attachment.id,
+                            name: attachment.name,
+                            contentType: attachment.contentType,
+                            size: attachment.size,
+                            isInline: attachment.isInline,
+                            contentId: attachment.contentId
+                        }));
+                        emailInfo.hasAttachments = true;
+                    }
+                    else {
+                        // Try getting attachments directly
+                        logger.log('Method 1: Direct attachment query...');
+                        const attachments = await graphClient
+                            .api(`/me/messages/${messageId}/attachments`)
+                            .select('id,name,contentType,size,isInline,contentId')
+                            .get();
+                        logger.log(`Method 1 results: Found ${attachments.value?.length || 0} attachments`);
+                        if (attachments && attachments.value && attachments.value.length > 0) {
+                            emailInfo.attachments = attachments.value.map((attachment) => ({
+                                id: attachment.id,
+                                name: attachment.name,
+                                contentType: attachment.contentType,
+                                size: attachment.size,
+                                isInline: attachment.isInline,
+                                contentId: attachment.contentId
+                            }));
+                            emailInfo.hasAttachments = true;
+                            logger.log(`Successfully retrieved ${emailInfo.attachments.length} attachments`);
+                        }
+                        else {
+                            logger.log('No attachments found with either method');
+                            emailInfo.attachments = [];
+                            emailInfo.hasAttachments = false;
+                        }
+                    }
+                }
+                catch (attachmentError) {
+                    logger.error('Error getting attachments:', attachmentError);
+                    logger.error('Error details:', JSON.stringify(attachmentError, null, 2));
+                    emailInfo.attachments = [];
+                    emailInfo.hasAttachments = false;
+                }
             }
             return emailInfo;
         }
         catch (error) {
             logger.error('Error getting email:', error);
+            logger.error('Error details:', JSON.stringify(error, null, 2));
             throw error;
         }
     }
@@ -380,111 +435,13 @@ export class MS365Operations {
             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
-            if (searchQuery) {
-                logger.log(`Search query: ${searchQuery}`);
-            }
-            if (filterQuery) {
-                logger.log(`Filter query: ${filterQuery}`);
-            }
-            let apiCall;
-            let useSearchAPI = !!searchQuery;
+            // For complex searches, use a simpler approach
             try {
-                // Microsoft Graph doesn't support $orderBy with $search, so we need to choose one approach
-                if (searchQuery) {
-                    // Use search API when we have search terms (no orderby allowed)
-                    // Add ConsistencyLevel header for search queries
-                    apiCall = graphClient.api('/me/messages')
-                        .select('id,subject,from,toRecipients,ccRecipients,receivedDateTime,sentDateTime,bodyPreview,isRead,hasAttachments,importance,conversationId,parentFolderId,webLink')
-                        .header('ConsistencyLevel', 'eventual')
-                        .search(searchQuery)
-                        .top(criteria.maxResults || 50);
-                    // Can't use filter with search, so we'll need to filter results manually if needed
-                }
-                else {
-                    // Use filter API when we don't have search terms (orderby allowed)
-                    apiCall = graphClient.api('/me/messages')
-                        .select('id,subject,from,toRecipients,ccRecipients,receivedDateTime,sentDateTime,bodyPreview,isRead,hasAttachments,importance,conversationId,parentFolderId,webLink')
-                        .orderby('receivedDateTime desc')
-                        .top(criteria.maxResults || 50);
-                    if (filterQuery) {
-                        apiCall = apiCall.filter(filterQuery);
-                    }
-                }
-                // Handle folder-specific searches
-                if (criteria.folder && criteria.folder !== 'inbox') {
-                    if (searchQuery) {
-                        // For folder + search, we need to use a different approach
-                        apiCall = graphClient.api(`/me/mailFolders/${criteria.folder}/messages`)
-                            .select('id,subject,from,toRecipients,ccRecipients,receivedDateTime,sentDateTime,bodyPreview,isRead,hasAttachments,importance,conversationId,parentFolderId,webLink')
-                            .top(criteria.maxResults || 50);
-                        if (filterQuery) {
-                            apiCall = apiCall.filter(filterQuery);
-                        }
-                        // Note: Folder-specific search is limited, we'll do text filtering on results
-                    }
-                    else {
-                        apiCall = graphClient.api(`/me/mailFolders/${criteria.folder}/messages`)
-                            .select('id,subject,from,toRecipients,ccRecipients,receivedDateTime,sentDateTime,bodyPreview,isRead,hasAttachments,importance,conversationId,parentFolderId,webLink')
-                            .orderby('receivedDateTime desc')
-                            .top(criteria.maxResults || 50);
-                        if (filterQuery) {
-                            apiCall = apiCall.filter(filterQuery);
-                        }
-                    }
-                }
+                // Start with a basic query to get recent emails
+                const apiCall = graphClient.api('/me/messages')
+                    .select('id,subject,from,toRecipients,ccRecipients,receivedDateTime,sentDateTime,bodyPreview,isRead,hasAttachments,importance,conversationId,parentFolderId,webLink')
+                    .orderby('receivedDateTime desc')
+                    .top(criteria.maxResults || 100);
                 const result = await apiCall.get();
                 let messages = result.value?.map((email) => ({
                     id: email.id,
@@ -511,79 +468,34 @@ export class MS365Operations {
                     parentFolderId: email.parentFolderId || '',
                     webLink: email.webLink || ''
                 })) || [];
-                // Apply manual filtering when using search (since we can't use $filter with $search)
-                if (useSearchAPI && (criteria.folder || filterQuery)) {
-                    messages = this.applyManualFiltering(messages, criteria);
+                // Apply manual filtering for all criteria
+                messages = this.applyManualFiltering(messages, criteria);
+                // For emails with attachments, get attachment counts
+                for (const message of messages) {
+                    if (message.hasAttachments) {
+                        try {
+                            const attachments = await graphClient
+                                .api(`/me/messages/${message.id}/attachments`)
+                                .select('id')
+                                .get();
+                            message.attachments = new Array(attachments.value?.length || 0);
+                        }
+                        catch (error) {
+                            logger.error(`Error getting attachment count for message ${message.id}:`, error);
+                            message.attachments = [];
+                        }
+                    }
                 }
-                const standardResult = {
+                const searchResult = {
                     messages,
                     hasMore: !!result['@odata.nextLink']
                 };
-                this.setCachedResults(cacheKey, standardResult);
-                return standardResult;
+                this.setCachedResults(cacheKey, searchResult);
+                return searchResult;
             }
-            catch (searchError) {
-                // If search API fails due to syntax error, fall back to filter-only approach
-                if (searchError.message && searchError.message.includes('Syntax error')) {
-                    logger.log('Search API failed with syntax error, falling back to filter-only query');
-                    // Fallback: Use only filter-based query without search
-                    apiCall = graphClient.api('/me/messages')
-                        .select('id,subject,from,toRecipients,ccRecipients,receivedDateTime,sentDateTime,bodyPreview,isRead,hasAttachments,importance,conversationId,parentFolderId,webLink')
-                        .orderby('receivedDateTime desc')
-                        .top(criteria.maxResults || 50);
-                    if (filterQuery) {
-                        apiCall = apiCall.filter(filterQuery);
-                    }
-                    // Handle folder-specific queries
-                    if (criteria.folder && criteria.folder !== 'inbox') {
-                        apiCall = graphClient.api(`/me/mailFolders/${criteria.folder}/messages`)
-                            .select('id,subject,from,toRecipients,ccRecipients,receivedDateTime,sentDateTime,bodyPreview,isRead,hasAttachments,importance,conversationId,parentFolderId,webLink')
-                            .orderby('receivedDateTime desc')
-                            .top(criteria.maxResults || 50);
-                        if (filterQuery) {
-                            apiCall = apiCall.filter(filterQuery);
-                        }
-                    }
-                    const result = await apiCall.get();
-                    let messages = result.value?.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 || ''
-                    })) || [];
-                    // 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);
-                    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 in email search:', error);
+                throw error;
             }
         }, 'searchEmails');
     }
@@ -935,53 +847,55 @@ export class MS365Operations {
      * 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;
+        const emails = [];
+        const batchSize = 20;
+        for (let i = 0; i < messageIds.length; i += batchSize) {
+            const batch = messageIds.slice(i, i + batchSize);
+            const batchPromises = batch.map(async (id) => {
+                try {
+                    const graphClient = await this.getGraphClient();
+                    const email = await graphClient
+                        .api(`/me/messages/${id}`)
+                        .select('id,subject,from,toRecipients,ccRecipients,receivedDateTime,sentDateTime,bodyPreview,isRead,hasAttachments,importance,conversationId,parentFolderId,webLink')
+                        .get();
+                    const emailInfo = {
+                        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 || '',
+                        attachments: [] // Initialize empty attachments array
+                    };
+                    return emailInfo;
+                }
+                catch (error) {
+                    logger.error(`Error getting email ${id}:`, error);
+                    return null;
+                }
+            });
+            const batchResults = await Promise.all(batchPromises);
+            const batchEmails = batchResults.filter((email) => email !== null);
+            emails.push(...batchEmails);
         }
+        return emails;
     }
     /**
      * Clear cached graph client (used when authentication fails)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ms365-mcp-server",
-  "version": "1.1.1",
+  "version": "1.1.3",
   "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",