ms365-mcp-server 1.1.10 → 1.1.11

package/dist/index.js

@@ -67,7 +67,7 @@ function parseArgs() {
 }
 const server = new Server({
     name: "ms365-mcp-server",
-    version: "1.1.10"
+    version: "1.1.11"
 }, {
     capabilities: {
         resources: {

package/dist/utils/ms365-operations.js

@@ -643,7 +643,7 @@ export class MS365Operations {
         }
     }
     /**
-     * Search emails with criteria
+     * Advanced email search using Microsoft Graph Search API with KQL - Persistent search until results found
      */
     async searchEmails(criteria = {}) {
         return await this.executeWithAuth(async () => {
@@ -654,152 +654,491 @@ export class MS365Operations {
             if (cachedResults) {
                 return cachedResults;
             }
-            // For complex searches, use a simpler approach
+            const maxResults = criteria.maxResults || 50;
+            let allMessages = [];
+            let searchAttempts = 0;
+            const maxAttempts = 6; // Try multiple strategies
+            logger.log(`🔍 Starting persistent search with criteria: ${JSON.stringify(criteria)}`);
             try {
-                // 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,
-                    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 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);
+                // Strategy 1: Use Microsoft Graph Search API for text-based queries
+                if (criteria.query && searchAttempts < maxAttempts) {
+                    searchAttempts++;
+                    logger.log(`🔍 Attempt ${searchAttempts}: Using Graph Search API for query: "${criteria.query}"`);
+                    const searchResults = await this.performGraphSearch(criteria.query, maxResults * 2); // Search for more to increase chances
+                    allMessages.push(...searchResults);
+                    if (allMessages.length > 0) {
+                        logger.log(`✅ Found ${allMessages.length} results with Graph Search API`);
+                    }
+                }
+                // Strategy 2: Use KQL (Keyword Query Language) for advanced searches
+                if (allMessages.length === 0 && searchAttempts < maxAttempts) {
+                    const kqlQuery = this.buildKQLQuery(criteria);
+                    if (kqlQuery) {
+                        searchAttempts++;
+                        logger.log(`🔍 Attempt ${searchAttempts}: Using KQL search: "${kqlQuery}"`);
+                        const kqlResults = await this.performKQLSearch(kqlQuery, maxResults * 2);
+                        allMessages.push(...kqlResults);
+                        if (allMessages.length > 0) {
+                            logger.log(`✅ Found ${allMessages.length} results with KQL search`);
                         }
-                        catch (error) {
-                            logger.error(`Error getting attachment count for message ${message.id}:`, error);
-                            message.attachments = [];
+                    }
+                }
+                // Strategy 3: Try relaxed KQL search (remove some constraints)
+                if (allMessages.length === 0 && searchAttempts < maxAttempts) {
+                    const relaxedKQL = this.buildRelaxedKQLQuery(criteria);
+                    if (relaxedKQL && relaxedKQL !== this.buildKQLQuery(criteria)) {
+                        searchAttempts++;
+                        logger.log(`🔍 Attempt ${searchAttempts}: Using relaxed KQL search: "${relaxedKQL}"`);
+                        const relaxedResults = await this.performKQLSearch(relaxedKQL, maxResults * 2);
+                        allMessages.push(...relaxedResults);
+                        if (allMessages.length > 0) {
+                            logger.log(`✅ Found ${allMessages.length} results with relaxed KQL search`);
                         }
                     }
                 }
+                // Strategy 4: OData filter search with broader scope
+                if (allMessages.length === 0 && searchAttempts < maxAttempts) {
+                    searchAttempts++;
+                    logger.log(`🔍 Attempt ${searchAttempts}: Using OData filter search with broader scope`);
+                    const filterResults = await this.performFilteredSearch(criteria, maxResults * 3); // Even broader search
+                    allMessages.push(...filterResults);
+                    if (allMessages.length > 0) {
+                        logger.log(`✅ Found ${allMessages.length} results with OData filter search`);
+                    }
+                }
+                // Strategy 5: Partial text search across recent emails (expanded scope)
+                if (allMessages.length === 0 && searchAttempts < maxAttempts) {
+                    searchAttempts++;
+                    logger.log(`🔍 Attempt ${searchAttempts}: Using expanded partial text search`);
+                    const partialResults = await this.performPartialTextSearch(criteria, maxResults * 4); // Very broad search
+                    allMessages.push(...partialResults);
+                    if (allMessages.length > 0) {
+                        logger.log(`✅ Found ${allMessages.length} results with partial text search`);
+                    }
+                }
+                // Strategy 6: Fallback to basic search with maximum scope
+                if (allMessages.length === 0 && searchAttempts < maxAttempts) {
+                    searchAttempts++;
+                    logger.log(`🔍 Attempt ${searchAttempts}: Using fallback basic search with maximum scope`);
+                    const basicResult = await this.performBasicSearch({
+                        ...criteria,
+                        maxResults: Math.max(maxResults * 5, 500) // Very large scope
+                    });
+                    allMessages.push(...basicResult.messages);
+                    if (allMessages.length > 0) {
+                        logger.log(`✅ Found ${allMessages.length} results with basic search fallback`);
+                    }
+                }
+                // Remove duplicates and apply advanced filtering
+                const uniqueMessages = this.removeDuplicateMessages(allMessages);
+                logger.log(`📧 After deduplication: ${uniqueMessages.length} unique messages`);
+                const filteredMessages = this.applyAdvancedFiltering(uniqueMessages, criteria);
+                logger.log(`📧 After advanced filtering: ${filteredMessages.length} filtered messages`);
+                // Sort by relevance and date
+                const sortedMessages = this.sortSearchResults(filteredMessages, criteria);
+                // If still no results, try one more time with very relaxed criteria
+                if (sortedMessages.length === 0 && (criteria.query || criteria.from || criteria.subject)) {
+                    logger.log(`🔍 Final attempt: Ultra-relaxed search for any partial matches`);
+                    const ultraRelaxedResults = await this.performUltraRelaxedSearch(criteria, maxResults * 3);
+                    const finalFiltered = this.applyUltraRelaxedFiltering(ultraRelaxedResults, criteria);
+                    if (finalFiltered.length > 0) {
+                        logger.log(`✅ Ultra-relaxed search found ${finalFiltered.length} results`);
+                        const limitedMessages = finalFiltered.slice(0, maxResults);
+                        const searchResult = {
+                            messages: limitedMessages,
+                            hasMore: finalFiltered.length > maxResults
+                        };
+                        this.setCachedResults(cacheKey, searchResult);
+                        return searchResult;
+                    }
+                }
+                // Limit results
+                const limitedMessages = sortedMessages.slice(0, maxResults);
                 const searchResult = {
-                    messages,
-                    hasMore: !!result['@odata.nextLink']
+                    messages: limitedMessages,
+                    hasMore: sortedMessages.length > maxResults
                 };
                 this.setCachedResults(cacheKey, searchResult);
+                logger.log(`🔍 Search completed after ${searchAttempts} attempts: ${limitedMessages.length} final results`);
+                if (limitedMessages.length === 0) {
+                    logger.log(`❌ No results found despite ${searchAttempts} search strategies. Consider broadening search criteria.`);
+                }
                 return searchResult;
             }
             catch (error) {
-                logger.error('Error in email search:', error);
-                throw error;
+                logger.error('Error in persistent email search:', error);
+                // Final fallback - get some recent emails and filter them
+                logger.log('🔄 Final fallback: getting recent emails to filter manually');
+                return await this.performBasicSearch(criteria);
             }
         }, 'searchEmails');
     }
     /**
-     * Apply manual filtering to search results (used when $filter can't be used with $search)
+     * Use Microsoft Graph Search API for full-text search
      */
-    applyManualFiltering(messages, criteria) {
+    async performGraphSearch(query, maxResults) {
+        try {
+            const graphClient = await this.getGraphClient();
+            const searchRequest = {
+                requests: [
+                    {
+                        entityTypes: ['message'],
+                        query: {
+                            queryString: query
+                        },
+                        from: 0,
+                        size: Math.min(maxResults, 1000), // Graph Search max is 1000
+                        fields: ['id', 'subject', 'from', 'toRecipients', 'ccRecipients', 'receivedDateTime', 'sentDateTime', 'bodyPreview', 'isRead', 'hasAttachments', 'importance', 'conversationId', 'parentFolderId', 'webLink']
+                    }
+                ]
+            };
+            const result = await graphClient
+                .api('/search/query')
+                .post(searchRequest);
+            const messages = [];
+            if (result.value?.[0]?.hitsContainers?.[0]?.hits) {
+                for (const hit of result.value[0].hitsContainers[0].hits) {
+                    const email = hit.resource;
+                    messages.push(this.mapEmailResult(email));
+                }
+            }
+            logger.log(`📧 Graph Search returned ${messages.length} results`);
+            return messages;
+        }
+        catch (error) {
+            logger.log(`❌ Graph Search failed: ${error}. Falling back to alternative search.`);
+            return [];
+        }
+    }
+    /**
+     * Build KQL (Keyword Query Language) for advanced searches
+     */
+    buildKQLQuery(criteria) {
+        const kqlParts = [];
+        if (criteria.from) {
+            // Smart sender search - handles partial names, emails, display names
+            const fromTerm = criteria.from.trim();
+            if (fromTerm.includes('@')) {
+                kqlParts.push(`from:${fromTerm}`);
+            }
+            else {
+                // For names, search in both from field and sender
+                kqlParts.push(`(from:"${fromTerm}" OR sender:"${fromTerm}" OR from:*${fromTerm}*)`);
+            }
+        }
+        if (criteria.to) {
+            kqlParts.push(`to:${criteria.to}`);
+        }
+        if (criteria.cc) {
+            kqlParts.push(`cc:${criteria.cc}`);
+        }
+        if (criteria.subject) {
+            kqlParts.push(`subject:"${criteria.subject}"`);
+        }
+        if (criteria.hasAttachment === true) {
+            kqlParts.push('hasattachment:true');
+        }
+        else if (criteria.hasAttachment === false) {
+            kqlParts.push('hasattachment:false');
+        }
+        if (criteria.isUnread === true) {
+            kqlParts.push('isread:false');
+        }
+        else if (criteria.isUnread === false) {
+            kqlParts.push('isread:true');
+        }
+        if (criteria.importance) {
+            kqlParts.push(`importance:${criteria.importance}`);
+        }
+        if (criteria.after) {
+            const afterDate = new Date(criteria.after).toISOString().split('T')[0];
+            kqlParts.push(`received>=${afterDate}`);
+        }
+        if (criteria.before) {
+            const beforeDate = new Date(criteria.before).toISOString().split('T')[0];
+            kqlParts.push(`received<=${beforeDate}`);
+        }
+        if (criteria.folder) {
+            kqlParts.push(`foldernames:"${criteria.folder}"`);
+        }
+        return kqlParts.join(' AND ');
+    }
+    /**
+     * Perform KQL-based search using Graph Search API
+     */
+    async performKQLSearch(kqlQuery, maxResults) {
+        try {
+            const graphClient = await this.getGraphClient();
+            const searchRequest = {
+                requests: [
+                    {
+                        entityTypes: ['message'],
+                        query: {
+                            queryString: kqlQuery
+                        },
+                        from: 0,
+                        size: Math.min(maxResults, 1000),
+                        fields: ['id', 'subject', 'from', 'toRecipients', 'ccRecipients', 'receivedDateTime', 'sentDateTime', 'bodyPreview', 'isRead', 'hasAttachments', 'importance', 'conversationId', 'parentFolderId', 'webLink']
+                    }
+                ]
+            };
+            const result = await graphClient
+                .api('/search/query')
+                .post(searchRequest);
+            const messages = [];
+            if (result.value?.[0]?.hitsContainers?.[0]?.hits) {
+                for (const hit of result.value[0].hitsContainers[0].hits) {
+                    const email = hit.resource;
+                    messages.push(this.mapEmailResult(email));
+                }
+            }
+            logger.log(`📧 KQL Search returned ${messages.length} results`);
+            return messages;
+        }
+        catch (error) {
+            logger.log(`❌ KQL Search failed: ${error}. Falling back to filter search.`);
+            return [];
+        }
+    }
+    /**
+     * Fallback to OData filter-based search
+     */
+    async performFilteredSearch(criteria, maxResults) {
+        try {
+            const graphClient = await this.getGraphClient();
+            let apiCall = graphClient
+                .api('/me/messages')
+                .select('id,subject,from,toRecipients,ccRecipients,receivedDateTime,sentDateTime,bodyPreview,isRead,hasAttachments,importance,conversationId,parentFolderId,webLink')
+                .orderby('receivedDateTime desc')
+                .top(Math.min(maxResults, 999));
+            // Apply OData filters where possible
+            const filters = [];
+            if (criteria.from && criteria.from.includes('@')) {
+                filters.push(`from/emailAddress/address eq '${criteria.from}'`);
+            }
+            if (criteria.to && criteria.to.includes('@')) {
+                filters.push(`toRecipients/any(r: r/emailAddress/address eq '${criteria.to}')`);
+            }
+            if (criteria.isUnread !== undefined) {
+                filters.push(`isRead eq ${!criteria.isUnread}`);
+            }
+            if (criteria.hasAttachment !== undefined) {
+                filters.push(`hasAttachments eq ${criteria.hasAttachment}`);
+            }
+            if (criteria.importance) {
+                filters.push(`importance eq '${criteria.importance}'`);
+            }
+            if (filters.length > 0) {
+                apiCall = apiCall.filter(filters.join(' and '));
+            }
+            // Apply folder filter using specific folder API
+            if (criteria.folder) {
+                const folders = await this.findFolderByName(criteria.folder);
+                if (folders.length > 0) {
+                    apiCall = graphClient
+                        .api(`/me/mailFolders/${folders[0].id}/messages`)
+                        .select('id,subject,from,toRecipients,ccRecipients,receivedDateTime,sentDateTime,bodyPreview,isRead,hasAttachments,importance,conversationId,parentFolderId,webLink')
+                        .orderby('receivedDateTime desc')
+                        .top(Math.min(maxResults, 999));
+                }
+            }
+            const result = await apiCall.get();
+            const messages = result.value?.map((email) => this.mapEmailResult(email)) || [];
+            logger.log(`📧 Filtered Search returned ${messages.length} results`);
+            return messages;
+        }
+        catch (error) {
+            logger.log(`❌ Filtered Search failed: ${error}`);
+            return [];
+        }
+    }
+    /**
+     * Fallback to basic search (original implementation)
+     */
+    async performBasicSearch(criteria) {
+        logger.log('🔄 Using fallback basic search');
+        const graphClient = await this.getGraphClient();
+        const result = await 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)
+            .get();
+        let messages = result.value?.map((email) => this.mapEmailResult(email)) || [];
+        messages = this.applyManualFiltering(messages, criteria);
+        return {
+            messages,
+            hasMore: !!result['@odata.nextLink']
+        };
+    }
+    /**
+     * Map email result to EmailInfo format
+     */
+    mapEmailResult(email) {
+        return {
+            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: []
+        };
+    }
+    /**
+     * Remove duplicate messages based on ID
+     */
+    removeDuplicateMessages(messages) {
+        const seen = new Set();
         return messages.filter(message => {
-            // Apply text search filters manually
+            if (seen.has(message.id)) {
+                return false;
+            }
+            seen.add(message.id);
+            return true;
+        });
+    }
+    /**
+     * Apply advanced filtering with better logic
+     */
+    applyAdvancedFiltering(messages, criteria) {
+        return messages.filter(message => {
+            // Enhanced text search across multiple fields
             if (criteria.query) {
-                const searchText = criteria.query.toLowerCase();
-                const messageText = `${message.subject} ${message.bodyPreview} ${message.from.name} ${message.from.address}`.toLowerCase();
-                if (!messageText.includes(searchText))
+                const searchText = criteria.query.toLowerCase().trim();
+                const searchableContent = [
+                    message.subject,
+                    message.bodyPreview,
+                    message.from.name,
+                    message.from.address,
+                    ...message.toRecipients.map(r => `${r.name} ${r.address}`),
+                    ...message.ccRecipients.map(r => `${r.name} ${r.address}`)
+                ].join(' ').toLowerCase();
+                // Support multiple search terms (AND logic)
+                const searchTerms = searchText.split(/\s+/).filter(term => term.length > 0);
+                if (!searchTerms.every(term => searchableContent.includes(term))) {
                     return false;
+                }
             }
+            // Enhanced sender search
             if (criteria.from) {
                 const searchTerm = criteria.from.toLowerCase().trim();
                 const fromName = message.from.name.toLowerCase();
                 const fromAddress = message.from.address.toLowerCase();
-                // Multiple matching strategies for better partial name support
                 const matches = [
-                    // Direct name or email match
                     fromName.includes(searchTerm),
                     fromAddress.includes(searchTerm),
-                    // Split search term and check if all parts exist in name
+                    // Split name search
                     searchTerm.split(/\s+/).every(part => fromName.includes(part)),
-                    // Check if any word in the name starts with the search term
-                    fromName.split(/\s+/).some(namePart => namePart.startsWith(searchTerm)),
-                    // Check if search term matches any word in the name exactly
-                    fromName.split(/\s+/).some(namePart => namePart === searchTerm),
-                    // Handle "Last, First" format
-                    fromName.replace(/,\s*/g, ' ').includes(searchTerm),
-                    // Handle initials (e.g., "M Kumar" for "Madan Kumar")
-                    searchTerm.split(/\s+/).length === 2 &&
-                        fromName.split(/\s+/).length >= 2 &&
-                        fromName.split(/\s+/)[0].startsWith(searchTerm.split(/\s+/)[0][0]) &&
-                        fromName.includes(searchTerm.split(/\s+/)[1])
+                    // Word boundary search
+                    new RegExp(`\\b${searchTerm.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`, 'i').test(fromName),
+                    // Email domain search
+                    searchTerm.includes('@') && fromAddress === searchTerm,
+                    // Partial email search
+                    !searchTerm.includes('@') && fromAddress.includes(searchTerm)
                 ];
                 if (!matches.some(match => match))
                     return false;
             }
-            if (criteria.to) {
-                const toMatch = message.toRecipients.some(recipient => recipient.address.toLowerCase() === criteria.to.toLowerCase());
-                if (!toMatch)
-                    return false;
-            }
-            if (criteria.cc) {
-                // Handle case where ccRecipients might be undefined
-                const ccMatch = message.ccRecipients && message.ccRecipients.length > 0 &&
-                    message.ccRecipients.some(recipient => recipient.address.toLowerCase() === criteria.cc.toLowerCase());
-                if (!ccMatch)
-                    return false;
-            }
-            if (criteria.subject) {
-                if (!message.subject.toLowerCase().includes(criteria.subject.toLowerCase()))
-                    return false;
-            }
-            // Apply date filters
-            if (criteria.after) {
-                const afterDate = new Date(criteria.after);
-                const messageDate = new Date(message.receivedDateTime);
-                if (messageDate < afterDate)
-                    return false;
-            }
-            if (criteria.before) {
-                const beforeDate = new Date(criteria.before);
+            // Date range filters
+            if (criteria.after || criteria.before) {
                 const messageDate = new Date(message.receivedDateTime);
-                if (messageDate > beforeDate)
-                    return false;
+                if (criteria.after) {
+                    const afterDate = new Date(criteria.after);
+                    if (messageDate < afterDate)
+                        return false;
+                }
+                if (criteria.before) {
+                    const beforeDate = new Date(criteria.before);
+                    if (messageDate > beforeDate)
+                        return false;
+                }
             }
-            // Apply attachment filter
-            if (criteria.hasAttachment !== undefined && message.hasAttachments !== criteria.hasAttachment) {
+            // Other filters remain the same but are more robust
+            if (criteria.to && !message.toRecipients.some(r => r.address.toLowerCase().includes(criteria.to.toLowerCase())))
                 return false;
-            }
-            // Apply read status filter
-            if (criteria.isUnread !== undefined && message.isRead === criteria.isUnread) {
+            if (criteria.cc && (!message.ccRecipients || !message.ccRecipients.some(r => r.address.toLowerCase().includes(criteria.cc.toLowerCase()))))
                 return false;
-            }
-            // Apply importance filter
-            if (criteria.importance && message.importance !== criteria.importance) {
+            if (criteria.subject && !message.subject.toLowerCase().includes(criteria.subject.toLowerCase()))
+                return false;
+            if (criteria.hasAttachment !== undefined && message.hasAttachments !== criteria.hasAttachment)
+                return false;
+            if (criteria.isUnread !== undefined && message.isRead === criteria.isUnread)
+                return false;
+            if (criteria.importance && message.importance !== criteria.importance)
                 return false;
-            }
             return true;
         });
     }
+    /**
+     * Sort search results by relevance and date
+     */
+    sortSearchResults(messages, criteria) {
+        return messages.sort((a, b) => {
+            // Calculate relevance score
+            const scoreA = this.calculateRelevanceScore(a, criteria);
+            const scoreB = this.calculateRelevanceScore(b, criteria);
+            if (scoreA !== scoreB) {
+                return scoreB - scoreA; // Higher score first
+            }
+            // If relevance is same, sort by date (newer first)
+            return new Date(b.receivedDateTime).getTime() - new Date(a.receivedDateTime).getTime();
+        });
+    }
+    /**
+     * Calculate relevance score for search results
+     */
+    calculateRelevanceScore(message, criteria) {
+        let score = 0;
+        if (criteria.query) {
+            const query = criteria.query.toLowerCase();
+            // Subject matches get higher score
+            if (message.subject.toLowerCase().includes(query))
+                score += 10;
+            // Sender name matches
+            if (message.from.name.toLowerCase().includes(query))
+                score += 5;
+            // Body preview matches
+            if (message.bodyPreview.toLowerCase().includes(query))
+                score += 3;
+            // Exact word matches get bonus
+            const words = query.split(/\s+/);
+            words.forEach(word => {
+                if (message.subject.toLowerCase().includes(word))
+                    score += 2;
+            });
+        }
+        // Recent emails get slight boost
+        const daysOld = (Date.now() - new Date(message.receivedDateTime).getTime()) / (1000 * 60 * 60 * 24);
+        if (daysOld < 7)
+            score += 2;
+        else if (daysOld < 30)
+            score += 1;
+        // Unread emails get boost
+        if (!message.isRead)
+            score += 1;
+        // Important emails get boost
+        if (message.importance === 'high')
+            score += 3;
+        return score;
+    }
     /**
      * List emails in a folder
      */
@@ -957,10 +1296,13 @@ export class MS365Operations {
             const graphClient = await this.getGraphClient();
             const allFolders = [];
             // Get top-level folders
+            logger.log('📁 Fetching top-level mail folders...');
             const result = await graphClient
                 .api('/me/mailFolders')
                 .select('id,displayName,totalItemCount,unreadItemCount,parentFolderId')
+                .top(999) // Request up to 999 folders to avoid pagination
                 .get();
+            logger.log(`📁 Found ${result.value?.length || 0} top-level folders from API`);
             // Process top-level folders
             const topLevelFolders = result.value?.map((folder) => ({
                 id: folder.id,
@@ -971,12 +1313,17 @@ export class MS365Operations {
                 depth: 0,
                 fullPath: folder.displayName || ''
             })) || [];
+            logger.log(`📁 Processed ${topLevelFolders.length} top-level folders: ${topLevelFolders.map((f) => f.displayName).join(', ')}`);
             allFolders.push(...topLevelFolders);
             // Recursively get child folders for each top-level folder
+            logger.log('📂 Starting recursive child folder discovery...');
             for (const folder of topLevelFolders) {
+                logger.log(`📂 Checking children of: ${folder.displayName} (${folder.id})`);
                 const childFolders = await this.getChildFolders(folder.id, folder.fullPath || folder.displayName, 1);
+                logger.log(`📂 Found ${childFolders.length} child folders for ${folder.displayName}`);
                 allFolders.push(...childFolders);
             }
+            logger.log(`📁 Total folders discovered: ${allFolders.length}`);
             // Sort folders by full path for better organization
             allFolders.sort((a, b) => (a.fullPath || '').localeCompare(b.fullPath || ''));
             return allFolders;
@@ -993,11 +1340,14 @@ export class MS365Operations {
         try {
             const graphClient = await this.getGraphClient();
             const childFolders = [];
+            logger.log(`📂 [Depth ${depth}] Getting child folders for: ${parentPath} (${parentFolderId})`);
             // Get child folders of the specified parent
             const result = await graphClient
                 .api(`/me/mailFolders/${parentFolderId}/childFolders`)
                 .select('id,displayName,totalItemCount,unreadItemCount,parentFolderId')
+                .top(999) // Request up to 999 child folders to avoid pagination
                 .get();
+            logger.log(`📂 [Depth ${depth}] API returned ${result.value?.length || 0} child folders for ${parentPath}`);
             if (result.value && result.value.length > 0) {
                 const folders = result.value.map((folder) => ({
                     id: folder.id,
@@ -1008,20 +1358,26 @@ export class MS365Operations {
                     depth,
                     fullPath: `${parentPath}/${folder.displayName || ''}`
                 }));
+                logger.log(`📂 [Depth ${depth}] Mapped child folders: ${folders.map((f) => f.displayName).join(', ')}`);
                 childFolders.push(...folders);
                 // Recursively get child folders (limit depth to prevent infinite recursion)
                 if (depth < 10) { // Max depth of 10 levels
+                    logger.log(`📂 [Depth ${depth}] Recursing into ${folders.length} child folders...`);
                     for (const folder of folders) {
                         const subChildFolders = await this.getChildFolders(folder.id, folder.fullPath || folder.displayName, depth + 1);
                         childFolders.push(...subChildFolders);
                     }
                 }
+                else {
+                    logger.log(`📂 [Depth ${depth}] Maximum depth reached, stopping recursion`);
+                }
             }
+            logger.log(`📂 [Depth ${depth}] Returning ${childFolders.length} total child folders for ${parentPath}`);
             return childFolders;
         }
         catch (error) {
             // Log the error but don't throw - some folders might not have children or access might be restricted
-            logger.log(`Could not access child folders for ${parentFolderId}: ${error instanceof Error ? error.message : String(error)}`);
+            logger.log(`❌ [Depth ${depth}] Could not access child folders for ${parentFolderId} (${parentPath}): ${error instanceof Error ? error.message : String(error)}`);
             return [];
         }
     }
@@ -1034,6 +1390,7 @@ export class MS365Operations {
             const result = await graphClient
                 .api(`/me/mailFolders/${parentFolderId}/childFolders`)
                 .select('id,displayName,totalItemCount,unreadItemCount,parentFolderId')
+                .top(999) // Request up to 999 child folders to avoid pagination
                 .get();
             return result.value?.map((folder) => ({
                 id: folder.id,
@@ -1337,5 +1694,286 @@ export class MS365Operations {
             throw error;
         }
     }
+    /**
+     * Debug method to check raw folder API response
+     */
+    async debugFolders() {
+        try {
+            const graphClient = await this.getGraphClient();
+            logger.log('🔍 DEBUG: Testing folder API calls...');
+            // Test basic folder listing
+            const basicResult = await graphClient
+                .api('/me/mailFolders')
+                .get();
+            logger.log(`🔍 DEBUG: Raw /me/mailFolders response: ${JSON.stringify(basicResult, null, 2)}`);
+            // Test with specific selection
+            const selectResult = await graphClient
+                .api('/me/mailFolders')
+                .select('id,displayName,totalItemCount,unreadItemCount,parentFolderId')
+                .get();
+            logger.log(`🔍 DEBUG: Selected fields response: ${JSON.stringify(selectResult, null, 2)}`);
+            // Test well-known folder access
+            try {
+                const inboxResult = await graphClient
+                    .api('/me/mailFolders/inbox/childFolders')
+                    .select('id,displayName,totalItemCount,unreadItemCount,parentFolderId')
+                    .get();
+                logger.log(`🔍 DEBUG: Inbox children: ${JSON.stringify(inboxResult, null, 2)}`);
+            }
+            catch (inboxError) {
+                logger.log(`🔍 DEBUG: Inbox children error: ${inboxError}`);
+            }
+        }
+        catch (error) {
+            logger.error('🔍 DEBUG: Error in debugFolders:', error);
+        }
+    }
+    /**
+     * Apply manual filtering to search results (used when $filter can't be used with $search)
+     */
+    applyManualFiltering(messages, criteria) {
+        return messages.filter(message => {
+            // Apply text search filters manually
+            if (criteria.query) {
+                const searchText = criteria.query.toLowerCase();
+                const messageText = `${message.subject} ${message.bodyPreview} ${message.from.name} ${message.from.address}`.toLowerCase();
+                if (!messageText.includes(searchText))
+                    return false;
+            }
+            if (criteria.from) {
+                const searchTerm = criteria.from.toLowerCase().trim();
+                const fromName = message.from.name.toLowerCase();
+                const fromAddress = message.from.address.toLowerCase();
+                const matches = [
+                    fromName.includes(searchTerm),
+                    fromAddress.includes(searchTerm),
+                    searchTerm.split(/\s+/).every(part => fromName.includes(part)),
+                    fromName.split(/\s+/).some(namePart => namePart.startsWith(searchTerm))
+                ];
+                if (!matches.some(match => match))
+                    return false;
+            }
+            if (criteria.to) {
+                const toMatch = message.toRecipients.some(recipient => recipient.address.toLowerCase() === criteria.to.toLowerCase());
+                if (!toMatch)
+                    return false;
+            }
+            if (criteria.cc) {
+                const ccMatch = message.ccRecipients && message.ccRecipients.length > 0 &&
+                    message.ccRecipients.some(recipient => recipient.address.toLowerCase() === criteria.cc.toLowerCase());
+                if (!ccMatch)
+                    return false;
+            }
+            if (criteria.subject) {
+                if (!message.subject.toLowerCase().includes(criteria.subject.toLowerCase()))
+                    return false;
+            }
+            if (criteria.after) {
+                const afterDate = new Date(criteria.after);
+                const messageDate = new Date(message.receivedDateTime);
+                if (messageDate < afterDate)
+                    return false;
+            }
+            if (criteria.before) {
+                const beforeDate = new Date(criteria.before);
+                const messageDate = new Date(message.receivedDateTime);
+                if (messageDate > beforeDate)
+                    return false;
+            }
+            if (criteria.hasAttachment !== undefined && message.hasAttachments !== criteria.hasAttachment) {
+                return false;
+            }
+            if (criteria.isUnread !== undefined && message.isRead === criteria.isUnread) {
+                return false;
+            }
+            if (criteria.importance && message.importance !== criteria.importance) {
+                return false;
+            }
+            return true;
+        });
+    }
+    /**
+     * Build relaxed KQL query with fewer constraints
+     */
+    buildRelaxedKQLQuery(criteria) {
+        const kqlParts = [];
+        // Only include the most important criteria for relaxed search
+        if (criteria.from) {
+            const fromTerm = criteria.from.trim();
+            if (fromTerm.includes('@')) {
+                // For email addresses, try domain search too
+                const domain = fromTerm.split('@')[1];
+                if (domain) {
+                    kqlParts.push(`(from:${fromTerm} OR from:*@${domain})`);
+                }
+                else {
+                    kqlParts.push(`from:${fromTerm}`);
+                }
+            }
+            else {
+                // For names, use wildcard search
+                kqlParts.push(`from:*${fromTerm}*`);
+            }
+        }
+        if (criteria.subject) {
+            // Use partial subject matching
+            kqlParts.push(`subject:*${criteria.subject}*`);
+        }
+        // Skip attachment and read status filters in relaxed mode
+        // Keep only critical filters
+        if (criteria.importance === 'high') {
+            kqlParts.push(`importance:high`);
+        }
+        // Expand date range for relaxed search
+        if (criteria.after) {
+            const afterDate = new Date(criteria.after);
+            afterDate.setDate(afterDate.getDate() - 7); // Expand by a week
+            const expandedDate = afterDate.toISOString().split('T')[0];
+            kqlParts.push(`received>=${expandedDate}`);
+        }
+        return kqlParts.join(' AND ');
+    }
+    /**
+     * Perform partial text search across recent emails with broader matching
+     */
+    async performPartialTextSearch(criteria, maxResults) {
+        try {
+            const graphClient = await this.getGraphClient();
+            // Get a large set of recent emails to search through
+            const result = await graphClient
+                .api('/me/messages')
+                .select('id,subject,from,toRecipients,ccRecipients,receivedDateTime,sentDateTime,bodyPreview,isRead,hasAttachments,importance,conversationId,parentFolderId,webLink')
+                .orderby('receivedDateTime desc')
+                .top(Math.min(maxResults, 1000))
+                .get();
+            const messages = result.value?.map((email) => this.mapEmailResult(email)) || [];
+            // Apply very broad partial matching
+            const partialMatches = messages.filter(message => {
+                let matches = true;
+                // Very flexible text search
+                if (criteria.query) {
+                    const searchTerms = criteria.query.toLowerCase().split(/\s+/);
+                    const searchableText = `${message.subject} ${message.bodyPreview} ${message.from.name} ${message.from.address}`.toLowerCase();
+                    // At least 50% of search terms should match
+                    const matchingTerms = searchTerms.filter(term => searchableText.includes(term));
+                    matches = matchingTerms.length >= Math.ceil(searchTerms.length * 0.5);
+                }
+                // Very flexible sender search
+                if (criteria.from && matches) {
+                    const fromTerm = criteria.from.toLowerCase();
+                    const fromText = `${message.from.name} ${message.from.address}`.toLowerCase();
+                    // Partial matching with character-level similarity
+                    matches = fromText.includes(fromTerm) ||
+                        fromTerm.split('').some(char => fromText.includes(char)) ||
+                        this.calculateStringSimilarity(fromTerm, fromText) > 0.3;
+                }
+                return matches;
+            });
+            logger.log(`📧 Partial text search found ${partialMatches.length} potential matches`);
+            return partialMatches;
+        }
+        catch (error) {
+            logger.log(`❌ Partial text search failed: ${error}`);
+            return [];
+        }
+    }
+    /**
+     * Ultra-relaxed search that casts a very wide net
+     */
+    async performUltraRelaxedSearch(criteria, maxResults) {
+        try {
+            const graphClient = await this.getGraphClient();
+            // Search across multiple folders and time ranges
+            const searches = [];
+            // Search recent emails
+            searches.push(graphClient
+                .api('/me/messages')
+                .select('id,subject,from,toRecipients,ccRecipients,receivedDateTime,sentDateTime,bodyPreview,isRead,hasAttachments,importance,conversationId,parentFolderId,webLink')
+                .orderby('receivedDateTime desc')
+                .top(500)
+                .get());
+            // Search sent items if looking for specific people
+            if (criteria.from || criteria.to) {
+                searches.push(graphClient
+                    .api('/me/mailFolders/sentitems/messages')
+                    .select('id,subject,from,toRecipients,ccRecipients,receivedDateTime,sentDateTime,bodyPreview,isRead,hasAttachments,importance,conversationId,parentFolderId,webLink')
+                    .orderby('receivedDateTime desc')
+                    .top(200)
+                    .get());
+            }
+            const results = await Promise.allSettled(searches);
+            const allEmails = [];
+            results.forEach((result, index) => {
+                if (result.status === 'fulfilled') {
+                    const emails = result.value.value?.map((email) => this.mapEmailResult(email)) || [];
+                    allEmails.push(...emails);
+                    logger.log(`📧 Ultra-relaxed search ${index + 1} found ${emails.length} emails`);
+                }
+            });
+            return this.removeDuplicateMessages(allEmails);
+        }
+        catch (error) {
+            logger.log(`❌ Ultra-relaxed search failed: ${error}`);
+            return [];
+        }
+    }
+    /**
+     * Ultra-relaxed filtering with very permissive matching
+     */
+    applyUltraRelaxedFiltering(messages, criteria) {
+        return messages.filter(message => {
+            let score = 0;
+            let hasAnyMatch = false;
+            // Any partial query match
+            if (criteria.query) {
+                const searchText = criteria.query.toLowerCase();
+                const messageText = `${message.subject} ${message.bodyPreview} ${message.from.name}`.toLowerCase();
+                // Check for any word matches
+                const queryWords = searchText.split(/\s+/);
+                const matchingWords = queryWords.filter(word => messageText.includes(word));
+                if (matchingWords.length > 0) {
+                    hasAnyMatch = true;
+                    score += matchingWords.length;
+                }
+            }
+            // Any sender similarity
+            if (criteria.from) {
+                const fromTerm = criteria.from.toLowerCase();
+                const fromText = `${message.from.name} ${message.from.address}`.toLowerCase();
+                if (fromText.includes(fromTerm) ||
+                    this.calculateStringSimilarity(fromTerm, fromText) > 0.2) {
+                    hasAnyMatch = true;
+                    score += 2;
+                }
+            }
+            // Any subject similarity
+            if (criteria.subject) {
+                const subjectTerm = criteria.subject.toLowerCase();
+                if (message.subject.toLowerCase().includes(subjectTerm)) {
+                    hasAnyMatch = true;
+                    score += 3;
+                }
+            }
+            // If no specific criteria, return recent emails
+            if (!criteria.query && !criteria.from && !criteria.subject) {
+                hasAnyMatch = true;
+            }
+            return hasAnyMatch;
+        }).sort((a, b) => {
+            // Sort by date for ultra-relaxed results
+            return new Date(b.receivedDateTime).getTime() - new Date(a.receivedDateTime).getTime();
+        });
+    }
+    /**
+     * Calculate string similarity (simple version)
+     */
+    calculateStringSimilarity(str1, str2) {
+        const longer = str1.length > str2.length ? str1 : str2;
+        const shorter = str1.length > str2.length ? str2 : str1;
+        if (longer.length === 0)
+            return 1.0;
+        const matches = shorter.split('').filter(char => longer.includes(char)).length;
+        return matches / longer.length;
+    }
 }
 export const ms365Operations = new MS365Operations();

package/package.json

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