ms365-mcp-server 1.1.2 → 1.1.4

package/README.md

@@ -252,6 +252,46 @@ ms365-mcp-server --login
 }
 ```
 
+### Attachment Management
+```javascript
+// Download a specific attachment
+{
+  "tool": "get_attachment",
+  "arguments": {
+    "messageId": "email_id",
+    "attachmentId": "attachment_id"
+  }
+}
+
+// Download all attachments from an email
+{
+  "tool": "get_attachment",
+  "arguments": {
+    "messageId": "email_id"
+  }
+}
+```
+
+### File Serving
+The server automatically serves downloaded attachments. By default, files are served at `http://localhost:55000/attachments/`. For production environments, configure the server URL using the `SERVER_URL` environment variable:
+
+```bash
+# Local development (default)
+SERVER_URL=http://localhost:55000 ms365-mcp-server
+
+# Production environment
+SERVER_URL=https://your-domain.com ms365-mcp-server
+```
+
+Files are:
+- Stored with unique names to prevent collisions
+- Available for 24 hours
+- Served with proper content types
+- Accessible via the configured server URL
+
+### Cleanup
+Attachments are automatically cleaned up after 24 hours. You can also manually delete files from the `public/attachments` directory.
+
 ## 🎯 Command Line Options
 
 ```bash

package/dist/index.js

@@ -4,6 +4,11 @@
  */
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import express from 'express';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import fs from 'fs/promises';
+import crypto from 'crypto';
 import { CallToolRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ListPromptsRequestSchema, ReadResourceRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
 import { logger } from './utils/api.js';
 import { MS365Operations } from './utils/ms365-operations.js';
@@ -55,7 +60,7 @@ function parseArgs() {
 }
 const server = new Server({
     name: "ms365-mcp-server",
-    version: "1.1.2"
+    version: "1.1.4"
 }, {
     capabilities: {
         resources: {
@@ -612,11 +617,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 +840,66 @@ 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) {
+                    throw new Error("messageId is 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");
+                    }
+                    // If specific attachmentId is provided, get that attachment
+                    if (args?.attachmentId) {
+                        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')}`);
                         }
-                    ]
-                };
+                        const attachment = await ms365Ops.getAttachment(args.messageId, args.attachmentId);
+                        // Save the attachment to file
+                        const savedFilename = await saveBase64ToFile(attachment.contentBytes, attachment.name);
+                        const fileUrl = `${SERVER_URL}/attachments/${savedFilename}`;
+                        attachment.fileUrl = fileUrl;
+                        const artifacts = getListOfArtifacts("get_attachment", [attachment]);
+                        const content = {
+                            type: "text",
+                            text: `📎 Attachment Downloaded\n\n📁 Name: ${attachment.name}\n💾 Size: ${attachment.size} bytes\n🗂️ Type: ${attachment.contentType}\n\n🔗 Download URL: ${fileUrl}\n\n💡 The file will be available for 24 hours.`
+                        };
+                        return {
+                            content: [content, ...artifacts]
+                        };
+                    }
+                    else {
+                        // Get all attachments
+                        const attachments = await Promise.all(email.attachments.map(async (att) => {
+                            const attachment = await ms365Ops.getAttachment(args.messageId, att.id);
+                            const savedFilename = await saveBase64ToFile(attachment.contentBytes, attachment.name);
+                            return {
+                                name: attachment.name,
+                                contentType: attachment.contentType,
+                                size: attachment.size,
+                                fileUrl: `${SERVER_URL}/attachments/${savedFilename}`
+                            };
+                        }));
+                        const artifacts = getListOfArtifacts("get_attachment", attachments);
+                        const content = {
+                            type: "text",
+                            text: `📎 Downloaded ${attachments.length} Attachments\n\n${attachments.map((att, index) => `${index + 1}. 📁 ${att.name}\n   💾 Size: ${att.size} bytes\n   🗂️ Type: ${att.contentType}\n   🔗 Download URL: ${att.fileUrl}\n`).join('\n')}\n\n💡 Files will be available for 24 hours.`
+                        };
+                        return {
+                            content: [content, ...artifacts]
+                        };
+                    }
+                }
+                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;
@@ -892,6 +969,140 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         };
     }
 });
+function generateAlphaNumericId(alphaSize = 3, numericSize = 3) {
+    const letters = 'abcdefghijklmnopqrstuvwxyz';
+    const digits = '0123456789';
+    let alphaPart = '';
+    let numericPart = '';
+    for (let i = 0; i < alphaSize; i++) {
+        alphaPart += letters.charAt(Math.floor(Math.random() * letters.length));
+    }
+    for (let i = 0; i < numericSize; i++) {
+        numericPart += digits.charAt(Math.floor(Math.random() * digits.length));
+    }
+    return alphaPart + numericPart;
+}
+function getListOfArtifacts(functionName, attachments) {
+    const artifacts = [];
+    attachments.forEach((attachment, i) => {
+        const url = attachment?.fileUrl || '';
+        const fileName = attachment?.name || '';
+        if (url) {
+            const timestamp = Math.floor(Date.now() / 1000); // seconds
+            const visitTimestamp = Date.now(); // milliseconds
+            const artifactData = {
+                id: `msg_browser_${generateAlphaNumericId()}`,
+                parentTaskId: `task_attachment_${generateAlphaNumericId()}`,
+                timestamp: timestamp,
+                agent: {
+                    id: "agent_siya_browser",
+                    name: "SIYA",
+                    type: "qna"
+                },
+                messageType: "action",
+                action: {
+                    tool: "browser",
+                    operation: "browsing",
+                    params: {
+                        url: `Filename: ${fileName}`,
+                        pageTitle: `Tool response for ${functionName}`,
+                        visual: {
+                            icon: "browser",
+                            color: "#2D8CFF"
+                        },
+                        stream: {
+                            type: "vnc",
+                            streamId: "stream_browser_1",
+                            target: "browser"
+                        }
+                    }
+                },
+                content: `Viewed page: ${functionName}`,
+                artifacts: [
+                    {
+                        id: "artifact_webpage_1746018877304_994",
+                        type: "browser_view",
+                        content: {
+                            url: url,
+                            title: functionName,
+                            screenshot: "",
+                            textContent: `Observed output of cmd \`${functionName}\` executed:`,
+                            extractedInfo: {}
+                        },
+                        metadata: {
+                            domainName: "example.com",
+                            visitTimestamp: visitTimestamp,
+                            category: "web_page"
+                        }
+                    }
+                ],
+                status: "completed"
+            };
+            const artifact = {
+                type: "text",
+                text: JSON.stringify(artifactData, null, 2),
+                title: `Filename: ${fileName}`,
+                format: "json"
+            };
+            artifacts.push(artifact);
+        }
+    });
+    return artifacts;
+}
+// Set up Express server for file serving
+const app = express();
+const PORT = process.env.PORT || 55000;
+const SERVER_URL = process.env.SERVER_URL || `http://localhost:${PORT}`;
+// Get the directory name in ESM
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// Serve static files from public directory
+app.use('/attachments', express.static(path.join(__dirname, '../public/attachments')));
+// Start Express server
+app.listen(PORT, () => {
+    logger.log(`File server running on ${SERVER_URL}`);
+});
+// Helper function to generate unique filenames
+function generateUniqueFilename(originalName) {
+    const timestamp = Date.now();
+    const randomString = crypto.randomBytes(8).toString('hex');
+    const extension = path.extname(originalName);
+    const baseName = path.basename(originalName, extension);
+    return `${baseName}-${timestamp}-${randomString}${extension}`;
+}
+// Helper function to save base64 content to file
+async function saveBase64ToFile(base64Content, filename) {
+    const uniqueFilename = generateUniqueFilename(filename);
+    const filePath = path.join(__dirname, '../public/attachments', uniqueFilename);
+    const buffer = Buffer.from(base64Content, 'base64');
+    await fs.writeFile(filePath, buffer);
+    return uniqueFilename;
+}
+// Helper function to clean up old attachments
+async function cleanupOldAttachments() {
+    const attachmentsDir = path.join(__dirname, '../public/attachments');
+    try {
+        const files = await fs.readdir(attachmentsDir);
+        const now = Date.now();
+        for (const file of files) {
+            const filePath = path.join(attachmentsDir, file);
+            const stats = await fs.stat(filePath);
+            const fileAge = now - stats.mtimeMs;
+            // Remove files older than 24 hours
+            if (fileAge > 24 * 60 * 60 * 1000) {
+                await fs.unlink(filePath);
+                logger.log(`Cleaned up old attachment: ${file}`);
+            }
+        }
+    }
+    catch (error) {
+        logger.error('Error cleaning up attachments:', error);
+    }
+}
+// Set up cleanup interval (run every hour)
+setInterval(cleanupOldAttachments, 60 * 60 * 1000);
+// Run initial cleanup
+cleanupOldAttachments();
 async function main() {
     ms365Config = parseArgs();
     if (ms365Config.setupAuth) {

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.2",
+  "version": "1.1.4",
   "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",
@@ -30,19 +30,21 @@
   ],
   "license": "MIT",
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.10.1",
     "@azure/msal-node": "^2.6.6",
     "@microsoft/microsoft-graph-client": "^3.0.7",
+    "@modelcontextprotocol/sdk": "^1.10.1",
+    "express": "^5.1.0",
     "isomorphic-fetch": "^3.0.0",
-    "open": "^10.1.0",
-    "mime-types": "^2.1.35",
     "keytar": "^7.9.0",
+    "mime-types": "^2.1.35",
+    "open": "^10.1.0",
     "typescript": "^5.0.4"
   },
   "devDependencies": {
-    "@types/node": "^20.2.3",
-    "@types/mime-types": "^2.1.4",
+    "@types/express": "^5.0.3",
     "@types/isomorphic-fetch": "^0.0.36",
+    "@types/mime-types": "^2.1.4",
+    "@types/node": "^20.2.3",
     "ts-node": "^10.9.1",
     "tsx": "^4.19.4"
   },