ms365-mcp-server 1.1.22 → 1.1.24

package/dist/index.js

@@ -145,7 +145,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
     const baseTools = [
         {
             name: "send_email",
-            description: "Send an email message with support for HTML content, attachments, and international characters. Supports both plain text and HTML emails with proper formatting.",
+            description: "Send an email message with support for HTML content, attachments (via file paths or Base64), and international characters. Supports both plain text and HTML emails with proper formatting. NEW: File path attachments with automatic MIME detection and Base64 conversion.",
             inputSchema: {
                 type: "object",
                 properties: {
@@ -209,16 +209,20 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                                 },
                                 contentBytes: {
                                     type: "string",
-                                    description: "Base64 encoded content of the attachment"
+                                    description: "Base64 encoded content of the attachment (required if filePath not provided)"
+                                },
+                                filePath: {
+                                    type: "string",
+                                    description: "ABSOLUTE PATH (full path) to the file to attach (alternative to contentBytes). MUST start with '/' - relative paths like './file.pdf' will NOT work. Supports Unicode filenames, spaces, and special characters. Example: '/Users/name/Documents/file with spaces.pdf'"
                                 },
                                 contentType: {
                                     type: "string",
-                                    description: "MIME type of the attachment (optional, auto-detected if not provided)"
+                                    description: "MIME type of the attachment (optional, auto-detected from file extension if not provided). Supports PDF, Office docs, images, text files, etc."
                                 }
                             },
-                            required: ["name", "contentBytes"]
+                            required: ["name"]
                         },
-                        description: "List of email attachments (optional)"
+                        description: "List of email attachments (optional). Each attachment can use either 'filePath' (ABSOLUTE PATH - must start with '/') or 'contentBytes' (Base64 encoded data). File paths support automatic MIME detection and Unicode filenames. IMPORTANT: Relative paths like './file.pdf' will fail."
                     }
                 },
                 required: ["to", "subject"]
@@ -379,16 +383,20 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                                 },
                                 contentBytes: {
                                     type: "string",
-                                    description: "Base64 encoded content of the attachment"
+                                    description: "Base64 encoded content of the attachment (required if filePath not provided)"
+                                },
+                                filePath: {
+                                    type: "string",
+                                    description: "ABSOLUTE PATH (full path) to the file to attach (alternative to contentBytes). MUST start with '/' - relative paths like './file.pdf' will NOT work. Supports Unicode filenames, spaces, and special characters. Example: '/Users/name/Documents/file with spaces.pdf'"
                                 },
                                 contentType: {
                                     type: "string",
-                                    description: "MIME type of the attachment (optional, auto-detected if not provided)"
+                                    description: "MIME type of the attachment (optional, auto-detected from file extension if not provided). Supports PDF, Office docs, images, text files, etc."
                                 }
                             },
-                            required: ["name", "contentBytes"]
+                            required: ["name"]
                         },
-                        description: "List of email attachments for draft (optional)"
+                        description: "List of email attachments for draft (optional). Each attachment can use either 'filePath' (ABSOLUTE PATH - must start with '/') or 'contentBytes' (Base64 encoded data). File paths support automatic MIME detection and Unicode filenames. IMPORTANT: Relative paths like './file.pdf' will fail."
                     },
                     // Additional draft parameters
                     draftId: {
@@ -899,6 +907,22 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
  */
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
+    // Debug logging for MCP protocol issues
+    logger.log(`🔧 MCP Tool Called: ${name}`);
+    logger.log(`🔧 Args type: ${typeof args}`);
+    logger.log(`🔧 Args content:`, JSON.stringify(args, null, 2));
+    // Handle string-encoded JSON arguments (common MCP client issue)
+    let processedArgs = args;
+    if (typeof args === 'string') {
+        try {
+            processedArgs = JSON.parse(args);
+            logger.log(`🔧 Parsed string args to object:`, JSON.stringify(processedArgs, null, 2));
+        }
+        catch (parseError) {
+            logger.error(`❌ Failed to parse string arguments: ${parseError}`);
+            throw new Error(`Invalid JSON in arguments: ${parseError}`);
+        }
+    }
     // Helper function to validate and normalize bodyType
     const normalizeBodyType = (bodyType) => {
         if (!bodyType)
@@ -916,7 +940,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         switch (name) {
             // ============ UNIFIED AUTHENTICATION TOOL ============
             case "authenticate":
-                const action = args?.action || 'login';
+                const action = processedArgs?.action || 'login';
                 switch (action) {
                     case "login":
                         try {
@@ -1043,9 +1067,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             // ============ UNIFIED EMAIL MANAGEMENT TOOL ============
             case "manage_email":
                 // Debug logging for parameter validation
-                logger.log('DEBUG: manage_email called with args:', JSON.stringify(args, null, 2));
+                logger.log('DEBUG: manage_email called with processedArgs:', JSON.stringify(processedArgs, null, 2));
                 if (ms365Config.multiUser) {
-                    const userId = args?.userId;
+                    const userId = processedArgs?.userId;
                     if (!userId) {
                         throw new Error("User ID is required in multi-user mode");
                     }
@@ -1056,14 +1080,14 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     const graphClient = await enhancedMS365Auth.getGraphClient();
                     ms365Ops.setGraphClient(graphClient);
                 }
-                const emailAction = args?.action;
+                const emailAction = processedArgs?.action;
                 logger.log(`DEBUG: Email action: ${emailAction}`);
                 switch (emailAction) {
                     case "read":
-                        if (!args?.messageId) {
+                        if (!processedArgs?.messageId) {
                             throw new Error("messageId is required for read action");
                         }
-                        const email = await ms365Ops.getEmail(args.messageId, args?.includeAttachments);
+                        const email = await ms365Ops.getEmail(processedArgs.messageId, processedArgs?.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`;
@@ -1095,12 +1119,12 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         };
                     case "search":
                         // Enhanced basic search with dynamic timeout based on search complexity
-                        const hasComplexFilters = !!(args?.query || args?.from || args?.subject || args?.after || args?.before);
+                        const hasComplexFilters = !!(processedArgs?.query || processedArgs?.from || processedArgs?.subject || processedArgs?.after || processedArgs?.before);
                         const baseTimeout = hasComplexFilters ? 60000 : 45000; // 60s for complex, 45s for simple
-                        const maxResults = args?.maxResults || 50;
+                        const maxResults = processedArgs?.maxResults || 50;
                         const adjustedTimeout = maxResults > 100 ? baseTimeout * 1.5 : baseTimeout; // Increase timeout for large result sets
                         logger.log(`🔍 Search timeout set to ${adjustedTimeout / 1000}s (complex: ${hasComplexFilters}, maxResults: ${maxResults})`);
-                        const searchPromise = ms365Ops.searchEmails(args);
+                        const searchPromise = ms365Ops.searchEmails(processedArgs);
                         const timeoutPromise = new Promise((_, reject) => {
                             setTimeout(() => {
                                 reject(new Error(`Search timed out after ${adjustedTimeout / 1000} seconds. For large mailboxes or complex searches, try: (1) ai_email_assistant with useLargeMailboxStrategy: true, (2) More specific search terms, (3) Smaller maxResults (current: ${maxResults}), or (4) Narrower date ranges.`));
@@ -1113,8 +1137,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         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`;
+                            if (processedArgs?.from) {
+                                responseText += `• Try partial names: "${processedArgs.from.split(' ')[0]}" or "${processedArgs.from.split(' ').pop()}"\n`;
                                 responseText += `• Check spelling of sender name\n`;
                             }
                             if (args?.subject) {
@@ -1324,7 +1348,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                             ]
                         };
                     case "draft":
-                        if (!args?.draftTo || !args?.draftSubject || !args?.draftBody) {
+                        if (!processedArgs?.draftTo || !processedArgs?.draftSubject || !processedArgs?.draftBody) {
                             throw new Error("draftTo, draftSubject, and draftBody are required for draft action");
                         }
                         // Helper function to normalize email arrays for drafts
@@ -1337,23 +1361,35 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                                 return field;
                             throw new Error(`Invalid email field format. Expected string or array of strings.`);
                         };
+                        // Process draft attachments (handle both filePath and contentBytes)
+                        let processedDraftAttachments = [];
+                        if (processedArgs.draftAttachments && Array.isArray(processedArgs.draftAttachments)) {
+                            processedDraftAttachments = await Promise.all(processedArgs.draftAttachments.map(async (attachment) => {
+                                try {
+                                    return await processAttachment(attachment);
+                                }
+                                catch (error) {
+                                    throw new Error(`Error processing draft attachment '${attachment.name}': ${error instanceof Error ? error.message : 'Unknown error'}`);
+                                }
+                            }));
+                        }
                         // Check if this looks like a reply based on subject
-                        const isLikelyReply = args.draftSubject?.toString().toLowerCase().startsWith('re:');
+                        const isLikelyReply = processedArgs.draftSubject?.toString().toLowerCase().startsWith('re:');
                         if (isLikelyReply) {
                             logger.log('🔔 SUGGESTION: Consider using "reply_draft" action instead of "draft" for threaded replies that appear in conversations');
                         }
                         const draftResult = await ms365Ops.saveDraftEmail({
-                            to: normalizeDraftEmailArray(args.draftTo),
-                            cc: normalizeDraftEmailArray(args.draftCc),
-                            bcc: normalizeDraftEmailArray(args.draftBcc),
-                            subject: args.draftSubject,
-                            body: args.draftBody,
-                            bodyType: normalizeBodyType(args.draftBodyType),
-                            importance: args.draftImportance || 'normal',
-                            attachments: args.draftAttachments,
-                            conversationId: args.conversationId
+                            to: normalizeDraftEmailArray(processedArgs.draftTo),
+                            cc: normalizeDraftEmailArray(processedArgs.draftCc),
+                            bcc: normalizeDraftEmailArray(processedArgs.draftBcc),
+                            subject: processedArgs.draftSubject,
+                            body: processedArgs.draftBody,
+                            bodyType: normalizeBodyType(processedArgs.draftBodyType),
+                            importance: processedArgs.draftImportance || 'normal',
+                            attachments: processedDraftAttachments,
+                            conversationId: processedArgs.conversationId
                         });
-                        let draftResponseText = `✅ Draft email saved successfully!\n📧 Subject: ${args.draftSubject}\n👥 To: ${Array.isArray(args.draftTo) ? args.draftTo.join(', ') : args.draftTo}\n🆔 Draft ID: ${draftResult.id}`;
+                        let draftResponseText = `✅ Draft email saved successfully!\n📧 Subject: ${processedArgs.draftSubject}\n👥 To: ${Array.isArray(processedArgs.draftTo) ? processedArgs.draftTo.join(', ') : processedArgs.draftTo}\n🆔 Draft ID: ${draftResult.id}${processedDraftAttachments.length > 0 ? `\n📎 Attachments: ${processedDraftAttachments.length} file(s)` : ''}`;
                         // Add helpful suggestion for threaded drafts
                         if (isLikelyReply) {
                             draftResponseText += `\n\n💡 TIP: This looks like a reply email. For drafts that appear in email threads, use "reply_draft" action with the original message ID instead of "draft".`;
@@ -1504,7 +1540,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             // ============ REMAINING ORIGINAL TOOLS ============
             case "send_email":
                 if (ms365Config.multiUser) {
-                    const userId = args?.userId;
+                    const userId = processedArgs?.userId;
                     if (!userId) {
                         throw new Error("User ID is required in multi-user mode");
                     }
@@ -1516,10 +1552,10 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     ms365Ops.setGraphClient(graphClient);
                 }
                 // Validate and normalize email input
-                if (!args?.to) {
+                if (!processedArgs?.to) {
                     throw new Error("'to' field is required for sending email");
                 }
-                if (!args?.subject) {
+                if (!processedArgs?.subject) {
                     throw new Error("'subject' field is required for sending email");
                 }
                 // Helper function to normalize email arrays
@@ -1532,30 +1568,42 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         return field;
                     throw new Error(`Invalid email field format. Expected string or array of strings.`);
                 };
+                // Process attachments (handle both filePath and contentBytes)
+                let processedAttachments = [];
+                if (processedArgs.attachments && Array.isArray(processedArgs.attachments)) {
+                    processedAttachments = await Promise.all(processedArgs.attachments.map(async (attachment) => {
+                        try {
+                            return await processAttachment(attachment);
+                        }
+                        catch (error) {
+                            throw new Error(`Error processing attachment '${attachment.name}': ${error instanceof Error ? error.message : 'Unknown error'}`);
+                        }
+                    }));
+                }
                 // Normalize the email message
                 const emailMessage = {
-                    to: normalizeEmailArray(args.to),
-                    cc: normalizeEmailArray(args.cc),
-                    bcc: normalizeEmailArray(args.bcc),
-                    subject: args.subject,
-                    body: args.body || '',
-                    bodyType: normalizeBodyType(args.bodyType),
-                    replyTo: args.replyTo,
-                    importance: args.importance || 'normal',
-                    attachments: args.attachments || []
+                    to: normalizeEmailArray(processedArgs.to),
+                    cc: normalizeEmailArray(processedArgs.cc),
+                    bcc: normalizeEmailArray(processedArgs.bcc),
+                    subject: processedArgs.subject,
+                    body: processedArgs.body || '',
+                    bodyType: normalizeBodyType(processedArgs.bodyType),
+                    replyTo: processedArgs.replyTo,
+                    importance: processedArgs.importance || 'normal',
+                    attachments: processedAttachments
                 };
                 const emailResult = await ms365Ops.sendEmail(emailMessage);
                 return {
                     content: [
                         {
                             type: "text",
-                            text: `✅ Email sent successfully!\n\n📧 To: ${Array.isArray(args?.to) ? args.to.join(', ') : args?.to}\n📋 Subject: ${args?.subject}\n🆔 Message ID: ${emailResult.id}`
+                            text: `✅ Email sent successfully!\n\n📧 To: ${Array.isArray(processedArgs?.to) ? processedArgs.to.join(', ') : processedArgs?.to}\n📋 Subject: ${processedArgs?.subject}\n🆔 Message ID: ${emailResult.id}${processedAttachments.length > 0 ? `\n📎 Attachments: ${processedAttachments.length} file(s)` : ''}`
                         }
                     ]
                 };
             case "get_attachment":
                 if (ms365Config.multiUser) {
-                    const userId = args?.userId;
+                    const userId = processedArgs?.userId;
                     if (!userId) {
                         throw new Error("User ID is required in multi-user mode");
                     }
@@ -1566,12 +1614,12 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     const graphClient = await enhancedMS365Auth.getGraphClient();
                     ms365Ops.setGraphClient(graphClient);
                 }
-                if (!args?.messageId) {
+                if (!processedArgs?.messageId) {
                     throw new Error("messageId is required");
                 }
                 try {
                     // First verify the email exists and has attachments
-                    const email = await ms365Ops.getEmail(args.messageId, true);
+                    const email = await ms365Ops.getEmail(processedArgs.messageId, true);
                     if (!email.hasAttachments) {
                         throw new Error("This email has no attachments");
                     }
@@ -1579,12 +1627,12 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         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 (processedArgs?.attachmentId) {
+                        const attachmentExists = email.attachments.some(att => att.id === processedArgs.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')}`);
+                            throw new Error(`Attachment ID ${processedArgs.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);
+                        const attachment = await ms365Ops.getAttachment(processedArgs.messageId, processedArgs.attachmentId);
                         // Save the attachment to file
                         const savedFilename = await saveBase64ToFile(attachment.contentBytes, attachment.name);
                         const fileUrl = `${SERVER_URL}/attachments/${savedFilename}`;
@@ -1601,7 +1649,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     else {
                         // Get all attachments
                         const attachments = await Promise.all(email.attachments.map(async (att) => {
-                            const attachment = await ms365Ops.getAttachment(args.messageId, att.id);
+                            const attachment = await ms365Ops.getAttachment(processedArgs.messageId, att.id);
                             const savedFilename = await saveBase64ToFile(attachment.contentBytes, attachment.name);
                             return {
                                 name: attachment.name,
@@ -1985,22 +2033,22 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                                 throw new Error(`Unknown classification action: ${classifyAction}`);
                         }
                     case 'process_attachments':
-                        if (!args?.messageId) {
+                        if (!processedArgs?.messageId) {
                             throw new Error("Message ID is required for attachment processing");
                         }
                         // Get the email and its attachments
-                        const email = await ms365Ops.getEmail(args.messageId, true);
+                        const email = await ms365Ops.getEmail(processedArgs?.messageId, true);
                         if (!email.hasAttachments || !email.attachments) {
                             throw new Error("This email has no attachments to process");
                         }
                         // Filter specific attachments if requested
                         let attachmentsToProcess = email.attachments;
-                        if (args?.attachmentIds && Array.isArray(args.attachmentIds)) {
-                            attachmentsToProcess = email.attachments.filter(att => args.attachmentIds.includes(att.id));
+                        if (processedArgs?.attachmentIds && Array.isArray(processedArgs.attachmentIds)) {
+                            attachmentsToProcess = email.attachments.filter(att => processedArgs.attachmentIds.includes(att.id));
                         }
                         // Download attachments and prepare for processing
                         const attachmentData = await Promise.all(attachmentsToProcess.map(async (att) => {
-                            const attachment = await ms365Ops.getAttachment(args.messageId, att.id);
+                            const attachment = await ms365Ops.getAttachment(processedArgs?.messageId, att.id);
                             return {
                                 id: att.id,
                                 name: att.name,
@@ -2530,6 +2578,81 @@ app.use(cors());
 // Get the directory name in ESM
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
+// Utility function to read file and convert to Base64
+async function fileToBase64(filePath) {
+    try {
+        // Check if path is absolute
+        if (!path.isAbsolute(filePath)) {
+            throw new Error(`File path must be absolute (start with '/'). Received relative path: ${filePath}. Example of correct path: '/Users/name/Documents/file.pdf'`);
+        }
+        // Normalize the file path to handle Unicode characters properly
+        const normalizedPath = path.normalize(filePath);
+        logger.log(`🔍 Attempting to read file: ${normalizedPath}`);
+        // Check if file exists and is readable
+        await fs.access(normalizedPath, fs.constants.R_OK);
+        // Get file stats
+        const stats = await fs.stat(normalizedPath);
+        if (!stats.isFile()) {
+            throw new Error(`Path is not a file: ${normalizedPath}`);
+        }
+        // Read file content
+        const buffer = await fs.readFile(normalizedPath);
+        const contentBytes = buffer.toString('base64');
+        // Auto-detect MIME type based on file extension
+        const ext = path.extname(normalizedPath).toLowerCase();
+        const mimeTypes = {
+            '.pdf': 'application/pdf',
+            '.doc': 'application/msword',
+            '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+            '.xls': 'application/vnd.ms-excel',
+            '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+            '.ppt': 'application/vnd.ms-powerpoint',
+            '.pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+            '.txt': 'text/plain',
+            '.csv': 'text/csv',
+            '.json': 'application/json',
+            '.xml': 'application/xml',
+            '.zip': 'application/zip',
+            '.jpg': 'image/jpeg',
+            '.jpeg': 'image/jpeg',
+            '.png': 'image/png',
+            '.gif': 'image/gif',
+            '.bmp': 'image/bmp',
+            '.svg': 'image/svg+xml'
+        };
+        const contentType = mimeTypes[ext] || 'application/octet-stream';
+        return {
+            contentBytes,
+            contentType,
+            size: stats.size
+        };
+    }
+    catch (error) {
+        logger.error(`❌ File read error for ${filePath}:`, error);
+        throw new Error(`Failed to read file ${filePath}: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}
+// Utility function to process attachment (handles both filePath and contentBytes)
+async function processAttachment(attachment) {
+    // If contentBytes is provided, use it directly
+    if (attachment.contentBytes) {
+        return {
+            name: attachment.name,
+            contentBytes: attachment.contentBytes,
+            contentType: attachment.contentType || 'application/octet-stream'
+        };
+    }
+    // If filePath is provided, read file and convert to Base64
+    if (attachment.filePath) {
+        const fileData = await fileToBase64(attachment.filePath);
+        return {
+            name: attachment.name,
+            contentBytes: fileData.contentBytes,
+            contentType: attachment.contentType || fileData.contentType
+        };
+    }
+    throw new Error(`Attachment ${attachment.name} must have either contentBytes or filePath`);
+}
 // Create public/attachments directory if it doesn't exist
 const attachmentsDir = path.join(__dirname, '../public/attachments');
 fs.mkdir(attachmentsDir, { recursive: true })

package/dist/utils/ms365-operations.js

@@ -186,12 +186,21 @@ export class MS365Operations {
                 searchTerms.push(`subject:${escapedSubject}`);
             }
         }
-        // ✅ SAFE: From search (supported by $search for names and emails)
+        // ✅ SAFE: Enhanced From search with smart email handling
         if (criteria.from) {
             const escapedFrom = criteria.from.replace(/"/g, '\\"');
             if (criteria.from.includes('@')) {
-                // Exact email search
-                searchTerms.push(`from:${escapedFrom}`);
+                // ENHANCED: Smart email search - prioritize local part for better fuzzy matching
+                const emailParts = criteria.from.split('@');
+                const localPart = emailParts[0];
+                // Use local part (username) for fuzzy matching - more reliable than exact email
+                if (localPart && localPart.length > 2) {
+                    searchTerms.push(`from:${localPart}`);
+                }
+                else {
+                    // Fallback to exact email if local part is too short
+                    searchTerms.push(`from:${escapedFrom}`);
+                }
             }
             else {
                 // Name search - use quotes for multi-word names
@@ -992,18 +1001,19 @@ ${originalBodyContent}
             const maxResults = criteria.maxResults || 50;
             let allMessages = [];
             // STRATEGY 1: Use $filter for structured queries (exact matches, dates, booleans)
-            const hasFilterableFields = !!((criteria.from && criteria.from.includes('@')) ||
-                (criteria.to && criteria.to.includes('@')) ||
+            // ENHANCED: Treat 'from' fields as searchable for better reliability
+            const hasFilterableFields = !!((criteria.to && criteria.to.includes('@')) ||
                 (criteria.cc && criteria.cc.includes('@')) ||
                 criteria.after ||
                 criteria.before ||
                 criteria.hasAttachment !== undefined ||
                 criteria.isUnread !== undefined ||
                 criteria.importance);
-            // STRATEGY 2: Use $search for text searches (subject, body content, from names)
+            // STRATEGY 2: Use $search for text searches (subject, body content, all from searches)
+            // ENHANCED: Always use search for 'from' field for better fuzzy matching
             const hasSearchableFields = !!(criteria.query ||
                 criteria.subject ||
-                (criteria.from && !criteria.from.includes('@')) // name searches
+                criteria.from // Always use search for from field (both names and emails)
             );
             try {
                 // STRATEGY 0: FOLDER SEARCH - Handle folder searches with optimized methods
@@ -1039,6 +1049,25 @@ ${originalBodyContent}
                 const sortedMessages = this.sortSearchResults(filteredMessages, criteria);
                 // Apply maxResults limit
                 const finalMessages = sortedMessages.slice(0, maxResults);
+                // ENHANCED: Smart fallback for empty results with 'from' field
+                if (finalMessages.length === 0 && criteria.from && criteria.from.includes('@')) {
+                    logger.log('🔄 No results found with exact search, trying fuzzy fallback...');
+                    // Extract local part for fuzzy search
+                    const localPart = criteria.from.split('@')[0];
+                    if (localPart && localPart.length > 2) {
+                        const fallbackCriteria = { ...criteria, from: localPart };
+                        const fallbackResult = await this.performPureSearchQuery(fallbackCriteria, maxResults);
+                        if (fallbackResult.length > 0) {
+                            logger.log(`🎯 Fuzzy fallback found ${fallbackResult.length} results`);
+                            const searchResult = {
+                                messages: fallbackResult.slice(0, maxResults),
+                                hasMore: fallbackResult.length > maxResults
+                            };
+                            this.setCachedResults(cacheKey, searchResult);
+                            return searchResult;
+                        }
+                    }
+                }
                 const searchResult = {
                     messages: finalMessages,
                     hasMore: sortedMessages.length > maxResults

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ms365-mcp-server",
-  "version": "1.1.22",
+  "version": "1.1.24",
   "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",
@@ -32,15 +32,15 @@
   "dependencies": {
     "@azure/msal-node": "^2.6.6",
     "@microsoft/microsoft-graph-client": "^3.0.7",
-    "@modelcontextprotocol/sdk": "^1.10.1",
+    "@modelcontextprotocol/sdk": "^1.18.1",
     "@types/cors": "^2.8.19",
     "cors": "^2.8.5",
     "express": "^5.1.0",
     "isomorphic-fetch": "^3.0.0",
     "keytar": "^7.9.0",
-    "mime-types": "^2.1.35",
-    "open": "^10.1.0",
-    "typescript": "^5.0.4"
+    "mime-types": "^3.0.1",
+    "open": "^10.2.0",
+    "typescript": "^5.7.2"
   },
   "devDependencies": {
     "@types/express": "^5.0.3",