ms365-mcp-server 1.1.10 → 1.1.12

package/dist/utils/ms365-operations.js

@@ -423,6 +423,54 @@ export class MS365Operations {
             throw error;
         }
     }
+    /**
+     * Verify draft threading by checking if draft appears in conversation
+     */
+    async verifyDraftThreading(draftId, originalConversationId) {
+        try {
+            const graphClient = await this.getGraphClient();
+            // Get the draft details
+            const draft = await graphClient
+                .api(`/me/messages/${draftId}`)
+                .select('id,subject,conversationId,parentFolderId,internetMessageHeaders,isDraft')
+                .get();
+            // Check if conversation IDs match
+            const conversationMatch = draft.conversationId === originalConversationId;
+            // Get all messages in the conversation to see if draft appears
+            let conversationMessages = [];
+            try {
+                const convResult = await graphClient
+                    .api('/me/messages')
+                    .filter(`conversationId eq '${originalConversationId}'`)
+                    .select('id,subject,isDraft,parentFolderId')
+                    .get();
+                conversationMessages = convResult.value || [];
+            }
+            catch (convError) {
+                logger.log(`Could not fetch conversation messages: ${convError}`);
+            }
+            const draftInConversation = conversationMessages.some((msg) => msg.id === draftId);
+            return {
+                isThreaded: conversationMatch && draftInConversation,
+                details: {
+                    draftConversationId: draft.conversationId,
+                    originalConversationId,
+                    conversationMatch,
+                    draftInConversation,
+                    draftFolder: draft.parentFolderId,
+                    conversationMessagesCount: conversationMessages.length,
+                    internetMessageHeaders: draft.internetMessageHeaders
+                }
+            };
+        }
+        catch (error) {
+            logger.error('Error verifying draft threading:', error);
+            return {
+                isThreaded: false,
+                details: { error: String(error) }
+            };
+        }
+    }
     /**
      * List draft emails
      */
@@ -477,27 +525,143 @@ export class MS365Operations {
     async createReplyDraft(originalMessageId, body, replyToAll = false) {
         try {
             const graphClient = await this.getGraphClient();
-            // Use Microsoft Graph's createReply endpoint for proper threading
-            const endpoint = replyToAll
-                ? `/me/messages/${originalMessageId}/createReplyAll`
-                : `/me/messages/${originalMessageId}/createReply`;
-            const requestBody = {};
-            // If body is provided, include it as a comment
-            if (body) {
-                requestBody.comment = body;
-            }
-            const replyDraft = await graphClient
-                .api(endpoint)
-                .post(requestBody);
-            return {
-                id: replyDraft.id,
-                subject: replyDraft.subject,
-                conversationId: replyDraft.conversationId,
-                toRecipients: replyDraft.toRecipients?.map((r) => r.emailAddress.address),
-                ccRecipients: replyDraft.ccRecipients?.map((r) => r.emailAddress.address),
-                bodyPreview: replyDraft.bodyPreview,
-                isDraft: replyDraft.isDraft
-            };
+            logger.log(`Creating reply draft for message: ${originalMessageId}`);
+            logger.log(`Reply to all: ${replyToAll}`);
+            // First, get the original message to include its content in the reply
+            const originalMessage = await graphClient
+                .api(`/me/messages/${originalMessageId}`)
+                .select('id,subject,from,toRecipients,ccRecipients,conversationId,parentFolderId,internetMessageId,internetMessageHeaders,conversationIndex,body,sentDateTime')
+                .get();
+            // Build the complete reply body with original content
+            const originalBodyContent = originalMessage.body?.content || '';
+            const fromDisplay = originalMessage.from?.emailAddress?.name || originalMessage.from?.emailAddress?.address || '';
+            const sentDate = new Date(originalMessage.sentDateTime).toLocaleString();
+            const completeReplyBody = `${body || ''}
+
+<br><br>
+<div style="border-left: 2px solid #ccc; padding-left: 10px; margin-top: 10px;">
+<p><strong>From:</strong> ${fromDisplay}<br>
+<strong>Sent:</strong> ${sentDate}<br>
+<strong>Subject:</strong> ${originalMessage.subject}</p>
+<hr style="border: none; border-top: 1px solid #ccc; margin: 10px 0;">
+${originalBodyContent}
+</div>`;
+            // First, try using the official Microsoft Graph createReply endpoint for proper threading
+            try {
+                const endpoint = replyToAll
+                    ? `/me/messages/${originalMessageId}/createReplyAll`
+                    : `/me/messages/${originalMessageId}/createReply`;
+                logger.log(`Using official Graph API endpoint: ${endpoint}`);
+                const replyDraft = await graphClient
+                    .api(endpoint)
+                    .post({
+                    message: {
+                        body: {
+                            contentType: 'html',
+                            content: completeReplyBody
+                        }
+                    }
+                });
+                logger.log(`Reply draft created successfully with ID: ${replyDraft.id}`);
+                logger.log(`Draft conversation ID: ${replyDraft.conversationId}`);
+                logger.log(`Draft appears as threaded reply in conversation with original content`);
+                return {
+                    id: replyDraft.id,
+                    subject: replyDraft.subject,
+                    conversationId: replyDraft.conversationId,
+                    toRecipients: replyDraft.toRecipients?.map((r) => r.emailAddress.address),
+                    ccRecipients: replyDraft.ccRecipients?.map((r) => r.emailAddress.address),
+                    bodyPreview: replyDraft.bodyPreview,
+                    isDraft: replyDraft.isDraft,
+                    parentFolderId: replyDraft.parentFolderId
+                };
+            }
+            catch (officialApiError) {
+                logger.log(`Official API failed: ${officialApiError}, trying fallback approach`);
+                logger.log(`Fallback: Creating manual reply draft with enhanced threading`);
+                logger.log(`Original message conversation ID: ${originalMessage.conversationId}`);
+                logger.log(`Original message folder: ${originalMessage.parentFolderId}`);
+                // Build proper References header from existing chain
+                let referencesHeader = originalMessage.internetMessageId || originalMessage.id;
+                if (originalMessage.internetMessageHeaders) {
+                    const existingReferences = originalMessage.internetMessageHeaders.find((h) => h.name.toLowerCase() === 'references');
+                    if (existingReferences && existingReferences.value) {
+                        referencesHeader = `${existingReferences.value} ${referencesHeader}`;
+                    }
+                }
+                const currentUserEmail = await this.getCurrentUserEmail();
+                const draftBody = {
+                    subject: originalMessage.subject?.startsWith('Re:') ? originalMessage.subject : `Re: ${originalMessage.subject}`,
+                    body: {
+                        contentType: 'html',
+                        content: completeReplyBody
+                    },
+                    conversationId: originalMessage.conversationId,
+                    internetMessageHeaders: [
+                        {
+                            name: 'X-In-Reply-To',
+                            value: originalMessage.internetMessageId || originalMessage.id
+                        },
+                        {
+                            name: 'X-References',
+                            value: referencesHeader
+                        },
+                        {
+                            name: 'X-Thread-Topic',
+                            value: originalMessage.subject?.replace(/^Re:\s*/i, '') || ''
+                        }
+                    ]
+                };
+                // Include conversation index if available for proper Outlook threading
+                if (originalMessage.conversationIndex) {
+                    draftBody.internetMessageHeaders.push({
+                        name: 'X-Thread-Index',
+                        value: originalMessage.conversationIndex
+                    });
+                }
+                // Set recipients based on reply type
+                if (replyToAll) {
+                    draftBody.toRecipients = [
+                        ...(originalMessage.from ? [{ emailAddress: originalMessage.from.emailAddress }] : []),
+                        ...(originalMessage.toRecipients || []).filter((r) => r.emailAddress.address !== currentUserEmail)
+                    ];
+                    draftBody.ccRecipients = originalMessage.ccRecipients || [];
+                }
+                else {
+                    draftBody.toRecipients = originalMessage.from ? [{ emailAddress: originalMessage.from.emailAddress }] : [];
+                }
+                // Create the fallback draft
+                const replyDraft = await graphClient
+                    .api('/me/messages')
+                    .post(draftBody);
+                logger.log(`Fallback reply draft created with ID: ${replyDraft.id}`);
+                logger.log(`Draft conversation ID: ${replyDraft.conversationId}`);
+                // Try to move the draft to the same folder as the original message for better threading
+                if (originalMessage.parentFolderId && originalMessage.parentFolderId !== 'drafts') {
+                    try {
+                        await graphClient
+                            .api(`/me/messages/${replyDraft.id}/move`)
+                            .post({
+                            destinationId: originalMessage.parentFolderId
+                        });
+                        logger.log(`Draft moved to original message folder: ${originalMessage.parentFolderId}`);
+                    }
+                    catch (moveError) {
+                        logger.log(`Could not move draft to original folder: ${moveError}`);
+                        // This is not critical, draft will remain in drafts folder
+                    }
+                }
+                return {
+                    id: replyDraft.id,
+                    subject: replyDraft.subject,
+                    conversationId: replyDraft.conversationId,
+                    toRecipients: replyDraft.toRecipients?.map((r) => r.emailAddress.address),
+                    ccRecipients: replyDraft.ccRecipients?.map((r) => r.emailAddress.address),
+                    bodyPreview: replyDraft.bodyPreview,
+                    isDraft: replyDraft.isDraft,
+                    parentFolderId: originalMessage.parentFolderId
+                };
+            }
         }
         catch (error) {
             throw new Error(`Error creating reply draft: ${error}`);
@@ -509,23 +673,106 @@ export class MS365Operations {
     async createForwardDraft(originalMessageId, comment) {
         try {
             const graphClient = await this.getGraphClient();
-            // Use Microsoft Graph's createForward endpoint for proper threading
-            const endpoint = `/me/messages/${originalMessageId}/createForward`;
-            const requestBody = {};
-            // If comment is provided, include it
-            if (comment) {
-                requestBody.comment = comment;
-            }
-            const forwardDraft = await graphClient
-                .api(endpoint)
-                .post(requestBody);
-            return {
-                id: forwardDraft.id,
-                subject: forwardDraft.subject,
-                conversationId: forwardDraft.conversationId,
-                bodyPreview: forwardDraft.bodyPreview,
-                isDraft: forwardDraft.isDraft
-            };
+            logger.log(`Creating forward draft for message: ${originalMessageId}`);
+            // First, try using the official Microsoft Graph createForward endpoint for proper threading
+            try {
+                logger.log(`Using official Graph API endpoint: /me/messages/${originalMessageId}/createForward`);
+                const forwardDraft = await graphClient
+                    .api(`/me/messages/${originalMessageId}/createForward`)
+                    .post({
+                    message: {
+                        body: {
+                            contentType: 'html',
+                            content: comment || ''
+                        }
+                    }
+                });
+                logger.log(`Forward draft created successfully with ID: ${forwardDraft.id}`);
+                logger.log(`Draft conversation ID: ${forwardDraft.conversationId}`);
+                logger.log(`Draft appears as threaded forward in conversation`);
+                return {
+                    id: forwardDraft.id,
+                    subject: forwardDraft.subject,
+                    conversationId: forwardDraft.conversationId,
+                    bodyPreview: forwardDraft.bodyPreview,
+                    isDraft: forwardDraft.isDraft,
+                    parentFolderId: forwardDraft.parentFolderId
+                };
+            }
+            catch (officialApiError) {
+                logger.log(`Official API failed: ${officialApiError}, trying fallback approach`);
+                // Fallback to manual creation if the official endpoint fails
+                const originalMessage = await graphClient
+                    .api(`/me/messages/${originalMessageId}`)
+                    .select('id,subject,from,toRecipients,ccRecipients,conversationId,parentFolderId,internetMessageId,internetMessageHeaders,conversationIndex,body,sentDateTime')
+                    .get();
+                logger.log(`Fallback: Creating manual forward draft with enhanced threading`);
+                logger.log(`Original message conversation ID: ${originalMessage.conversationId}`);
+                logger.log(`Original message folder: ${originalMessage.parentFolderId}`);
+                // Build proper References header from existing chain
+                let referencesHeader = originalMessage.internetMessageId || originalMessage.id;
+                if (originalMessage.internetMessageHeaders) {
+                    const existingReferences = originalMessage.internetMessageHeaders.find((h) => h.name.toLowerCase() === 'references');
+                    if (existingReferences && existingReferences.value) {
+                        referencesHeader = `${existingReferences.value} ${referencesHeader}`;
+                    }
+                }
+                const forwardedBody = `${comment ? comment + '\n\n' : ''}---------- Forwarded message ----------\nFrom: ${originalMessage.from?.emailAddress?.name || originalMessage.from?.emailAddress?.address}\nDate: ${originalMessage.sentDateTime}\nSubject: ${originalMessage.subject}\nTo: ${originalMessage.toRecipients?.map((r) => r.emailAddress.address).join(', ')}\n\n${originalMessage.body?.content || ''}`;
+                const draftBody = {
+                    subject: originalMessage.subject?.startsWith('Fwd:') ? originalMessage.subject : `Fwd: ${originalMessage.subject}`,
+                    body: {
+                        contentType: originalMessage.body?.contentType || 'html',
+                        content: forwardedBody
+                    },
+                    conversationId: originalMessage.conversationId,
+                    internetMessageHeaders: [
+                        {
+                            name: 'X-References',
+                            value: referencesHeader
+                        },
+                        {
+                            name: 'X-Thread-Topic',
+                            value: originalMessage.subject?.replace(/^(Re:|Fwd?):\s*/i, '') || ''
+                        }
+                    ]
+                };
+                // Include conversation index if available for proper Outlook threading
+                if (originalMessage.conversationIndex) {
+                    draftBody.internetMessageHeaders.push({
+                        name: 'X-Thread-Index',
+                        value: originalMessage.conversationIndex
+                    });
+                }
+                // Create the fallback draft
+                const forwardDraft = await graphClient
+                    .api('/me/messages')
+                    .post(draftBody);
+                logger.log(`Fallback forward draft created with ID: ${forwardDraft.id}`);
+                logger.log(`Draft conversation ID: ${forwardDraft.conversationId}`);
+                // Try to move the draft to the same folder as the original message for better threading
+                if (originalMessage.parentFolderId && originalMessage.parentFolderId !== 'drafts') {
+                    try {
+                        await graphClient
+                            .api(`/me/messages/${forwardDraft.id}/move`)
+                            .post({
+                            destinationId: originalMessage.parentFolderId
+                        });
+                        logger.log(`Draft moved to original message folder: ${originalMessage.parentFolderId}`);
+                    }
+                    catch (moveError) {
+                        logger.log(`Could not move draft to original folder: ${moveError}`);
+                        // This is not critical, draft will remain in drafts folder
+                    }
+                }
+                return {
+                    id: forwardDraft.id,
+                    subject: forwardDraft.subject,
+                    conversationId: forwardDraft.conversationId,
+                    bodyPreview: forwardDraft.bodyPreview,
+                    isDraft: forwardDraft.isDraft,
+                    parentFolderId: originalMessage.parentFolderId
+                };
+            }
         }
         catch (error) {
             throw new Error(`Error creating forward draft: ${error}`);
@@ -643,163 +890,591 @@ 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 () => {
             const graphClient = await this.getGraphClient();
+            logger.log(`🔍 Starting email search with criteria:`, JSON.stringify(criteria, null, 2));
             // Create cache key from criteria
             const cacheKey = JSON.stringify(criteria);
             const cachedResults = this.getCachedResults(cacheKey);
             if (cachedResults) {
+                logger.log('📦 Returning cached results');
                 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 reliable OData filter search first (has proper IDs)
+                if (searchAttempts < maxAttempts) {
+                    searchAttempts++;
+                    logger.log(`🔍 Attempt ${searchAttempts}: Using reliable OData filter search first`);
+                    const filterResults = await this.performFilteredSearch(criteria, maxResults * 2);
+                    allMessages.push(...filterResults);
+                    if (allMessages.length > 0) {
+                        logger.log(`✅ Found ${allMessages.length} results with OData filter search`);
+                    }
+                }
+                // Strategy 2: Use Microsoft Graph Search API for text-based queries (backup)
+                if (allMessages.length === 0 && 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 3: 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 4: 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 5: If we found results but they have UNKNOWN IDs, try to resolve them
+                if (allMessages.length > 0 && allMessages.some(msg => msg.id === 'UNKNOWN')) {
+                    logger.log(`🔍 Attempting to resolve UNKNOWN message IDs using direct message queries`);
+                    allMessages = await this.resolveUnknownMessageIds(allMessages, criteria);
+                }
+                // Strategy 6: 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 7: 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)
+     * Resolve UNKNOWN message IDs by finding messages using alternative search criteria
      */
-    applyManualFiltering(messages, criteria) {
+    async resolveUnknownMessageIds(messages, criteria) {
+        try {
+            const graphClient = await this.getGraphClient();
+            const resolvedMessages = [];
+            for (const message of messages) {
+                if (message.id === 'UNKNOWN') {
+                    // Try to find this message using subject and sender
+                    try {
+                        const searchFilter = [];
+                        if (message.subject) {
+                            searchFilter.push(`subject eq '${message.subject.replace(/'/g, "''")}'`);
+                        }
+                        if (message.from?.address) {
+                            searchFilter.push(`from/emailAddress/address eq '${message.from.address}'`);
+                        }
+                        if (searchFilter.length > 0) {
+                            const result = await graphClient
+                                .api('/me/messages')
+                                .filter(searchFilter.join(' and '))
+                                .select('id,subject,from,toRecipients,ccRecipients,receivedDateTime,sentDateTime,bodyPreview,isRead,hasAttachments,importance,conversationId,parentFolderId,webLink')
+                                .top(1)
+                                .get();
+                            if (result.value && result.value.length > 0) {
+                                const resolvedMessage = this.mapEmailResult(result.value[0]);
+                                logger.log(`✅ Resolved UNKNOWN ID to: ${resolvedMessage.id}`);
+                                resolvedMessages.push(resolvedMessage);
+                                continue;
+                            }
+                        }
+                    }
+                    catch (resolveError) {
+                        logger.log(`⚠️ Could not resolve message ID: ${resolveError}`);
+                    }
+                }
+                // If we couldn't resolve it, keep the original message
+                resolvedMessages.push(message);
+            }
+            return resolvedMessages;
+        }
+        catch (error) {
+            logger.log(`⚠️ Error resolving unknown message IDs: ${error}`);
+            return messages; // Return original messages if resolution fails
+        }
+    }
+    /**
+     * Use Microsoft Graph Search API for full-text search
+     */
+    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']
+                    }
+                ]
+            };
+            logger.log(`🔍 Graph Search request:`, JSON.stringify(searchRequest, null, 2));
+            const result = await graphClient
+                .api('/search/query')
+                .post(searchRequest);
+            logger.log(`🔍 Graph Search raw response:`, JSON.stringify(result, null, 2));
+            const messages = [];
+            if (result.value?.[0]?.hitsContainers?.[0]?.hits) {
+                logger.log(`🔍 Processing ${result.value[0].hitsContainers[0].hits.length} hits`);
+                for (const hit of result.value[0].hitsContainers[0].hits) {
+                    const email = hit.resource;
+                    logger.log(`🔍 Raw email from Graph Search:`, JSON.stringify(email, null, 2));
+                    const mappedEmail = this.mapEmailResult(email);
+                    logger.log(`🔍 Mapped email:`, JSON.stringify(mappedEmail, null, 2));
+                    messages.push(mappedEmail);
+                }
+            }
+            else {
+                logger.log(`🔍 No hits found in Graph Search response structure`);
+            }
+            logger.log(`📧 Graph Search returned ${messages.length} results`);
+            return messages;
+        }
+        catch (error) {
+            logger.log(`❌ Graph Search failed: ${error}. Falling back to alternative search.`);
+            logger.error(`❌ Graph Search error details:`, JSON.stringify(error, null, 2));
+            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) {
+        // Extract ID from various possible locations in the response
+        let emailId = email.id;
+        if (!emailId) {
+            // Try alternative ID sources
+            emailId = email['@odata.id'] ||
+                email.internetMessageId ||
+                email._id ||
+                email.messageId ||
+                email.resource?.id;
+            // If still no ID, try to extract from webLink or other fields
+            if (!emailId && email.webLink) {
+                const linkMatch = email.webLink.match(/itemid=([^&]+)/i);
+                if (linkMatch) {
+                    emailId = decodeURIComponent(linkMatch[1]);
+                }
+            }
+            // Log the raw email object for debugging when ID is missing
+            if (!emailId) {
+                logger.log('DEBUG: Email object missing ID after all attempts:', JSON.stringify(email, null, 2));
+                emailId = 'UNKNOWN';
+            }
+            else {
+                logger.log(`DEBUG: Found email ID from alternative source: ${emailId}`);
+            }
+        }
+        return {
+            id: emailId,
+            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);
+            // Date range filters
+            if (criteria.after || criteria.before) {
                 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.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 +1632,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 +1649,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 +1676,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 +1694,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 +1726,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 +2030,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();