ms365-mcp-server 1.1.15 → 1.1.17

package/dist/utils/ms365-operations.js

@@ -116,47 +116,36 @@ export class MS365Operations {
         }
     }
     /**
-     * Build filter query for Microsoft Graph API
+     * Build OData filter query (STRICT - only filterable fields)
+     * CRITICAL: Cannot mix with $search operations per Graph API limitations
      */
     buildFilterQuery(criteria) {
         const filters = [];
-        if (criteria.from) {
-            // Properly escape single quotes in email addresses and names
+        // ✅ SAFE: from/emailAddress fields are filterable
+        if (criteria.from && criteria.from.includes('@')) {
+            // Only exact email matches in filters - names require $search
             const escapedFrom = this.escapeODataValue(criteria.from);
-            if (criteria.from.includes('@')) {
-                // For email addresses, use exact match
-                filters.push(`from/emailAddress/address eq '${escapedFrom}'`);
-            }
-            else {
-                // For names, use contains for partial matching
-                filters.push(`contains(from/emailAddress/name,'${escapedFrom}')`);
-            }
+            filters.push(`from/emailAddress/address eq '${escapedFrom}'`);
         }
+        // ✅ SAFE: toRecipients/ccRecipients with proper any() syntax
         if (criteria.to && criteria.to.includes('@')) {
-            // Properly escape single quotes in email addresses
             const escapedTo = this.escapeODataValue(criteria.to);
             filters.push(`toRecipients/any(r: r/emailAddress/address eq '${escapedTo}')`);
         }
         if (criteria.cc && criteria.cc.includes('@')) {
-            // Properly escape single quotes in email addresses
             const escapedCc = this.escapeODataValue(criteria.cc);
             filters.push(`ccRecipients/any(r: r/emailAddress/address eq '${escapedCc}')`);
         }
-        if (criteria.subject) {
-            // Properly escape single quotes in subject
-            const escapedSubject = this.escapeODataValue(criteria.subject);
-            filters.push(`contains(subject,'${escapedSubject}')`);
-        }
+        // ✅ SAFE: Date filters with proper ISO 8601 format
         if (criteria.after) {
-            // Fix date formatting - use proper ISO format with quotes
             const afterDate = this.formatDateForOData(criteria.after);
             filters.push(`receivedDateTime ge '${afterDate}'`);
         }
         if (criteria.before) {
-            // Fix date formatting - use proper ISO format with quotes
             const beforeDate = this.formatDateForOData(criteria.before);
             filters.push(`receivedDateTime le '${beforeDate}'`);
         }
+        // ✅ SAFE: Boolean filters
         if (criteria.hasAttachment !== undefined) {
             filters.push(`hasAttachments eq ${criteria.hasAttachment}`);
         }
@@ -166,57 +155,57 @@ export class MS365Operations {
         if (criteria.importance) {
             filters.push(`importance eq '${criteria.importance}'`);
         }
+        // ❌ REMOVED: subject filtering - must use $search for subject content
+        // ❌ REMOVED: from name filtering - must use $search for partial names
         return filters.join(' and ');
     }
     /**
-     * Build search query for Microsoft Graph API
+     * Build search query for Microsoft Graph API (STRICT - only searchable fields)
+     * CRITICAL: Cannot mix with $filter operations per Graph API limitations
+     * $search ONLY works on: subject, body, from (not to, cc, categories, etc.)
      */
     buildSearchQuery(criteria) {
         const searchTerms = [];
+        // ✅ SAFE: General text search (searches subject, body, from automatically)
         if (criteria.query) {
-            searchTerms.push(criteria.query);
-        }
-        // Build email-specific search terms using proper Microsoft Graph syntax
-        const emailSearchTerms = [];
-        if (criteria.from) {
-            // Check if it looks like an email address for exact matching
-            if (criteria.from.includes('@')) {
-                emailSearchTerms.push(`from:${criteria.from}`);
+            // Escape quotes and use proper search syntax
+            const escapedQuery = criteria.query.replace(/"/g, '\\"');
+            if (escapedQuery.includes(' ')) {
+                searchTerms.push(`"${escapedQuery}"`);
             }
             else {
-                // For names, use general search which is more flexible with partial matching
-                // This will trigger manual filtering which supports partial names better
-                if (criteria.query) {
-                    searchTerms.push(`${criteria.query} AND ${criteria.from}`);
-                }
-                else {
-                    searchTerms.push(criteria.from);
-                }
+                searchTerms.push(escapedQuery);
             }
         }
-        if (criteria.to) {
-            emailSearchTerms.push(`to:${criteria.to}`);
-        }
-        if (criteria.cc) {
-            emailSearchTerms.push(`cc:${criteria.cc}`);
-        }
-        // Combine email search terms with OR logic
-        if (emailSearchTerms.length > 0) {
-            searchTerms.push(emailSearchTerms.join(' OR '));
-        }
+        // ✅ SAFE: Subject search (explicit field supported by $search)
         if (criteria.subject) {
-            // For subject searches, use proper syntax based on content
-            const subjectTerm = criteria.subject.trim();
-            if (subjectTerm.includes(' ') || subjectTerm.includes('"')) {
-                // If contains spaces or quotes, wrap in quotes and escape any internal quotes
-                const escapedSubject = subjectTerm.replace(/"/g, '\\"');
+            const escapedSubject = criteria.subject.replace(/"/g, '\\"');
+            if (escapedSubject.includes(' ')) {
                 searchTerms.push(`subject:"${escapedSubject}"`);
             }
             else {
-                // Simple single word, no quotes needed
-                searchTerms.push(`subject:${subjectTerm}`);
+                searchTerms.push(`subject:${escapedSubject}`);
+            }
+        }
+        // ✅ SAFE: From search (supported by $search for names and emails)
+        if (criteria.from) {
+            const escapedFrom = criteria.from.replace(/"/g, '\\"');
+            if (criteria.from.includes('@')) {
+                // Exact email search
+                searchTerms.push(`from:${escapedFrom}`);
+            }
+            else {
+                // Name search - use quotes for multi-word names
+                if (escapedFrom.includes(' ')) {
+                    searchTerms.push(`from:"${escapedFrom}"`);
+                }
+                else {
+                    searchTerms.push(`from:${escapedFrom}`);
+                }
             }
         }
+        // ❌ REMOVED: to/cc searches - NOT supported by $search
+        // These will be handled by manual filtering after retrieval
         return searchTerms.join(' AND ');
     }
     /**
@@ -988,12 +977,12 @@ ${originalBodyContent}
         }
     }
     /**
-     * Advanced email search using Microsoft Graph Search API with KQL - Returns ALL matching results
+     * GRAPH API COMPLIANT SEARCH - Respects Microsoft's strict limitations
+     * Strategy: Use EITHER $filter OR $search, never both
      */
     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));
+            logger.log(`🔍 GRAPH API COMPLIANT SEARCH with criteria:`, JSON.stringify(criteria, null, 2));
             // Create cache key from criteria
             const cacheKey = JSON.stringify(criteria);
             const cachedResults = this.getCachedResults(cacheKey);
@@ -1001,140 +990,214 @@ ${originalBodyContent}
                 logger.log('📦 Returning cached results');
                 return cachedResults;
             }
-            // If maxResults is specified, use it; otherwise get ALL results (with safety limit)
-            const maxResults = criteria.maxResults || 0; // 0 means no limit
-            const safetyLimit = 1000; // Maximum results to return even when maxResults is 0
-            const effectiveMaxResults = maxResults > 0 ? maxResults : safetyLimit;
+            const maxResults = criteria.maxResults || 50;
             let allMessages = [];
-            let searchAttempts = 0;
-            const maxAttempts = 6; // Try multiple strategies
-            // Add timeout mechanism (5 minutes max)
-            const searchTimeout = 5 * 60 * 1000; // 5 minutes
-            const startTime = Date.now();
-            logger.log(`🔍 Starting persistent search with criteria: ${JSON.stringify(criteria)}`);
-            logger.log(`🔍 Max results requested: ${maxResults === 0 ? 'ALL (limited to ' + safetyLimit + ' for safety)' : maxResults}`);
-            logger.log(`🔍 Search timeout: ${searchTimeout / 1000} seconds`);
+            // STRATEGY 1: Use $filter for structured queries (exact matches, dates, booleans)
+            const hasFilterableFields = !!((criteria.from && criteria.from.includes('@')) ||
+                (criteria.to && criteria.to.includes('@')) ||
+                (criteria.cc && criteria.cc.includes('@')) ||
+                criteria.after ||
+                criteria.before ||
+                criteria.hasAttachment !== undefined ||
+                criteria.isUnread !== undefined ||
+                criteria.importance);
+            // STRATEGY 2: Use $search for text searches (subject, body content, from names)
+            const hasSearchableFields = !!(criteria.query ||
+                criteria.subject ||
+                (criteria.from && !criteria.from.includes('@')) // name searches
+            );
             try {
-                // Strategy 1: Use reliable OData filter search first (has proper IDs) - Get ALL results
-                if (searchAttempts < maxAttempts && (Date.now() - startTime) < searchTimeout) {
-                    searchAttempts++;
-                    logger.log(`🔍 Attempt ${searchAttempts}: Using reliable OData filter search to get ALL results`);
-                    const filterResults = await this.performFilteredSearchAll(criteria);
-                    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) - Get ALL results
-                if (allMessages.length === 0 && criteria.query && searchAttempts < maxAttempts && (Date.now() - startTime) < searchTimeout) {
-                    searchAttempts++;
-                    logger.log(`🔍 Attempt ${searchAttempts}: Using Graph Search API for query: "${criteria.query}" to get ALL results`);
-                    const searchResults = await this.performGraphSearchAll(criteria.query);
-                    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 - Get ALL results
-                if (allMessages.length === 0 && searchAttempts < maxAttempts && (Date.now() - startTime) < searchTimeout) {
-                    const kqlQuery = this.buildKQLQuery(criteria);
-                    if (kqlQuery) {
-                        searchAttempts++;
-                        logger.log(`🔍 Attempt ${searchAttempts}: Using KQL search: "${kqlQuery}" to get ALL results`);
-                        const kqlResults = await this.performKQLSearchAll(kqlQuery);
-                        allMessages.push(...kqlResults);
-                        if (allMessages.length > 0) {
-                            logger.log(`✅ Found ${allMessages.length} results with KQL search`);
-                        }
-                    }
-                }
-                // Strategy 4: Try relaxed KQL search (remove some constraints) - Get ALL results
-                if (allMessages.length === 0 && searchAttempts < maxAttempts && (Date.now() - startTime) < searchTimeout) {
-                    const relaxedKQL = this.buildRelaxedKQLQuery(criteria);
-                    if (relaxedKQL && relaxedKQL !== this.buildKQLQuery(criteria)) {
-                        searchAttempts++;
-                        logger.log(`🔍 Attempt ${searchAttempts}: Using relaxed KQL search: "${relaxedKQL}" to get ALL results`);
-                        const relaxedResults = await this.performKQLSearchAll(relaxedKQL);
-                        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') && (Date.now() - startTime) < searchTimeout) {
-                    logger.log(`🔍 Attempting to resolve UNKNOWN message IDs using direct message queries`);
-                    allMessages = await this.resolveUnknownMessageIds(allMessages, criteria);
-                }
-                // Strategy 6: Partial text search across ALL recent emails (expanded scope)
-                if (allMessages.length === 0 && searchAttempts < maxAttempts && (Date.now() - startTime) < searchTimeout) {
-                    searchAttempts++;
-                    logger.log(`🔍 Attempt ${searchAttempts}: Using expanded partial text search across ALL emails`);
-                    const partialResults = await this.performPartialTextSearchAll(criteria);
-                    allMessages.push(...partialResults);
-                    if (allMessages.length > 0) {
-                        logger.log(`✅ Found ${allMessages.length} results with partial text search`);
-                    }
-                }
-                // Strategy 7: Fallback to basic search with ALL results
-                if (allMessages.length === 0 && searchAttempts < maxAttempts && (Date.now() - startTime) < searchTimeout) {
-                    searchAttempts++;
-                    logger.log(`🔍 Attempt ${searchAttempts}: Using fallback basic search to get ALL results`);
-                    const basicResult = await this.performBasicSearchAll(criteria);
-                    allMessages.push(...basicResult.messages);
-                    if (allMessages.length > 0) {
-                        logger.log(`✅ Found ${allMessages.length} results with basic search fallback`);
-                    }
-                }
-                // Check if we hit the timeout
-                if ((Date.now() - startTime) >= searchTimeout) {
-                    logger.log(`⚠️ Search timeout reached after ${(Date.now() - startTime) / 1000} seconds. Returning partial results.`);
+                // STRATEGY A: Pure Filter Strategy (when no search fields present)
+                if (hasFilterableFields && !hasSearchableFields) {
+                    logger.log('🔍 Using PURE FILTER strategy (structured queries only)');
+                    allMessages = await this.performPureFilterSearch(criteria, maxResults);
+                }
+                // STRATEGY B: Pure Search Strategy (when no filter fields present)
+                else if (hasSearchableFields && !hasFilterableFields) {
+                    logger.log('🔍 Using PURE SEARCH strategy (text search only)');
+                    allMessages = await this.performPureSearchQuery(criteria, maxResults);
+                }
+                // STRATEGY C: Hybrid Strategy (filter first, then search within results)
+                else if (hasFilterableFields && hasSearchableFields) {
+                    logger.log('🔍 Using HYBRID strategy (filter first, then search within results)');
+                    allMessages = await this.performHybridFilterThenSearch(criteria, maxResults);
+                }
+                // STRATEGY D: Fallback to basic list with manual filtering
+                else {
+                    logger.log('🔍 Using FALLBACK strategy (basic list with manual filtering)');
+                    const basicResult = await this.performBasicSearch(criteria);
+                    allMessages = basicResult.messages;
                 }
-                // 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`);
+                // Apply manual filtering for unsupported fields (to/cc names, complex logic)
+                const filteredMessages = this.applyManualFiltering(allMessages, criteria);
                 // 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) && (Date.now() - startTime) < searchTimeout) {
-                    logger.log(`🔍 Final attempt: Ultra-relaxed search for any partial matches across ALL emails`);
-                    const ultraRelaxedResults = await this.performUltraRelaxedSearchAll(criteria);
-                    const finalFiltered = this.applyUltraRelaxedFiltering(ultraRelaxedResults, criteria);
-                    if (finalFiltered.length > 0) {
-                        logger.log(`✅ Ultra-relaxed search found ${finalFiltered.length} results`);
-                        // Apply maxResults limit if specified
-                        const finalMessages = maxResults > 0 ? finalFiltered.slice(0, maxResults) : finalFiltered.slice(0, safetyLimit);
-                        const searchResult = {
-                            messages: finalMessages,
-                            hasMore: maxResults > 0 ? finalFiltered.length > maxResults : finalFiltered.length > safetyLimit
-                        };
-                        this.setCachedResults(cacheKey, searchResult);
-                        return searchResult;
-                    }
-                }
-                // Apply maxResults limit if specified, otherwise return all results (with safety limit)
-                const finalMessages = maxResults > 0 ? sortedMessages.slice(0, maxResults) : sortedMessages.slice(0, safetyLimit);
+                // Apply maxResults limit
+                const finalMessages = sortedMessages.slice(0, maxResults);
                 const searchResult = {
                     messages: finalMessages,
-                    hasMore: maxResults > 0 ? sortedMessages.length > maxResults : sortedMessages.length > safetyLimit
+                    hasMore: sortedMessages.length > maxResults
                 };
                 this.setCachedResults(cacheKey, searchResult);
-                logger.log(`🔍 Search completed after ${searchAttempts} attempts: ${finalMessages.length} final results (${maxResults > 0 ? 'limited' : 'safety-limited'}) in ${(Date.now() - startTime) / 1000} seconds`);
-                if (finalMessages.length === 0) {
-                    logger.log(`❌ No results found despite ${searchAttempts} search strategies. Consider broadening search criteria.`);
-                }
+                logger.log(`🔍 COMPLIANT SEARCH completed: ${finalMessages.length} results`);
                 return searchResult;
             }
             catch (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.performBasicSearchAll(criteria);
+                logger.error('Error in compliant email search:', error);
+                // Final fallback
+                return await this.performBasicSearch(criteria);
             }
         }, 'searchEmails');
     }
+    /**
+     * PURE FILTER SEARCH - Only uses $filter, never $search
+     * Use for: exact email matches, dates, booleans, importance
+     */
+    async performPureFilterSearch(criteria, maxResults) {
+        try {
+            const graphClient = await this.getGraphClient();
+            const filterString = this.buildFilterQuery(criteria);
+            if (!filterString) {
+                logger.log('⚠️ No valid filters for pure filter search');
+                return [];
+            }
+            logger.log(`🔍 Pure Filter Query: ${filterString}`);
+            let apiCall = graphClient
+                .api('/me/messages')
+                .filter(filterString)
+                .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(`📧 Pure Filter Search returned ${messages.length} results`);
+            return messages;
+        }
+        catch (error) {
+            logger.log(`❌ Pure Filter Search failed: ${error}`);
+            return [];
+        }
+    }
+    /**
+     * PURE SEARCH QUERY - Only uses $search, never $filter
+     * Use for: text searches in subject, body, from names
+     */
+    async performPureSearchQuery(criteria, maxResults) {
+        try {
+            const graphClient = await this.getGraphClient();
+            const searchString = this.buildSearchQuery(criteria);
+            if (!searchString) {
+                logger.log('⚠️ No valid search terms for pure search query');
+                return [];
+            }
+            logger.log(`🔍 Pure Search Query: ${searchString}`);
+            // Use Graph Search API for pure text searches
+            const searchRequest = {
+                requests: [
+                    {
+                        entityTypes: ['message'],
+                        query: {
+                            queryString: searchString
+                        },
+                        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) {
+                    messages.push(this.mapEmailResult(hit.resource));
+                }
+            }
+            logger.log(`📧 Pure Search Query returned ${messages.length} results`);
+            return messages;
+        }
+        catch (error) {
+            logger.log(`❌ Pure Search Query failed: ${error}`);
+            return [];
+        }
+    }
+    /**
+     * HYBRID STRATEGY - Filter first, then search within results
+     * Step 1: Use $filter to narrow down results structurally
+     * Step 2: Apply manual text filtering to remaining results
+     */
+    async performHybridFilterThenSearch(criteria, maxResults) {
+        try {
+            // Step 1: Create filter-only criteria
+            const filterCriteria = {
+                from: criteria.from?.includes('@') ? criteria.from : undefined,
+                to: criteria.to?.includes('@') ? criteria.to : undefined,
+                cc: criteria.cc?.includes('@') ? criteria.cc : undefined,
+                after: criteria.after,
+                before: criteria.before,
+                hasAttachment: criteria.hasAttachment,
+                isUnread: criteria.isUnread,
+                importance: criteria.importance,
+                maxResults: maxResults * 3 // Get more results for subsequent filtering
+            };
+            // Get filtered results
+            const filteredResults = await this.performPureFilterSearch(filterCriteria, maxResults * 3);
+            if (filteredResults.length === 0) {
+                logger.log('🔍 Hybrid: No results from filter step, trying pure search');
+                return await this.performPureSearchQuery(criteria, maxResults);
+            }
+            logger.log(`🔍 Hybrid: Filter step returned ${filteredResults.length} results, now applying search`);
+            // Step 2: Apply search criteria manually to filtered results
+            const searchCriteria = {
+                query: criteria.query,
+                subject: criteria.subject,
+                from: criteria.from?.includes('@') ? undefined : criteria.from, // Only names for search
+            };
+            const finalResults = this.applyManualSearchFiltering(filteredResults, searchCriteria);
+            logger.log(`🔍 Hybrid: Final results after search filtering: ${finalResults.length}`);
+            return finalResults.slice(0, maxResults);
+        }
+        catch (error) {
+            logger.log(`❌ Hybrid search failed: ${error}`);
+            return [];
+        }
+    }
+    /**
+     * Apply manual search filtering for text-based criteria
+     * Used in hybrid strategy to search within already filtered results
+     */
+    applyManualSearchFiltering(messages, criteria) {
+        return messages.filter(message => {
+            // General query search across multiple fields
+            if (criteria.query) {
+                const searchText = criteria.query.toLowerCase().trim();
+                const searchableContent = [
+                    message.subject,
+                    message.bodyPreview,
+                    message.from.name,
+                    message.from.address
+                ].join(' ').toLowerCase();
+                const searchTerms = searchText.split(/\s+/).filter(term => term.length > 0);
+                if (!searchTerms.every(term => searchableContent.includes(term))) {
+                    return false;
+                }
+            }
+            // Subject search
+            if (criteria.subject) {
+                const subjectMatch = message.subject.toLowerCase().includes(criteria.subject.toLowerCase());
+                if (!subjectMatch)
+                    return false;
+            }
+            // From name search (not email address)
+            if (criteria.from && !criteria.from.includes('@')) {
+                const fromNameMatch = message.from.name.toLowerCase().includes(criteria.from.toLowerCase());
+                if (!fromNameMatch)
+                    return false;
+            }
+            return true;
+        });
+    }
     /**
      * Resolve UNKNOWN message IDs by finding messages using alternative search criteria
      */
@@ -1396,23 +1459,10 @@ ${originalBodyContent}
                 logger.log(`🔍 Applying OData filter: ${filterString}`);
                 apiCall = apiCall.filter(filterString);
             }
-            // Apply folder filter using specific folder API
+            // Apply folder filter using optimized folder search
             if (criteria.folder) {
-                const folders = await this.findFolderByName(criteria.folder);
-                if (folders.length > 0) {
-                    logger.log(`🔍 Switching to folder-specific search: ${folders[0].displayName} (${folders[0].id})`);
-                    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));
-                    // Re-apply filters for folder-specific search
-                    if (filters.length > 0) {
-                        const filterString = filters.join(' and ');
-                        logger.log(`🔍 Applying OData filter to folder search: ${filterString}`);
-                        apiCall = apiCall.filter(filterString);
-                    }
-                }
+                logger.log(`🔍 Using optimized folder search for: ${criteria.folder}`);
+                return await this.performOptimizedFolderSearch(criteria, maxResults);
             }
             const result = await apiCall.get();
             const messages = result.value?.map((email) => this.mapEmailResult(email)) || [];
@@ -2619,23 +2669,16 @@ ${originalBodyContent}
                     logger.log(`🔍 Applying OData filter: ${filterString}`);
                     apiCall = apiCall.filter(filterString);
                 }
-                // Apply folder filter using specific folder API
+                // For folder searches, use optimized approach
                 if (criteria.folder) {
-                    const folders = await this.findFolderByName(criteria.folder);
-                    if (folders.length > 0) {
-                        logger.log(`🔍 Switching to folder-specific search: ${folders[0].displayName} (${folders[0].id})`);
-                        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(999);
-                        // Re-apply filters for folder-specific search
-                        if (filters.length > 0) {
-                            const filterString = filters.join(' and ');
-                            logger.log(`🔍 Applying OData filter to folder search: ${filterString}`);
-                            apiCall = apiCall.filter(filterString);
-                        }
-                    }
+                    logger.log(`🔍 Using optimized folder search (ALL mode) for: ${criteria.folder}`);
+                    // Use optimized search but allow unlimited results
+                    const originalMaxResults = criteria.maxResults;
+                    criteria.maxResults = 9999; // Set high limit for "ALL" mode
+                    const result = await this.performOptimizedFolderSearch(criteria, 9999);
+                    criteria.maxResults = originalMaxResults; // Restore original
+                    allMessages.push(...result);
+                    break; // Exit the pagination loop since we got the results
                 }
                 // Use nextLink if available for pagination
                 if (nextLink) {
@@ -2945,31 +2988,169 @@ ${originalBodyContent}
         } while (nextLink);
         return allMessages;
     }
+    /**
+     * Fast OData filter search - optimized for speed
+     */
+    async performFilteredSearchFast(criteria) {
+        try {
+            const graphClient = await this.getGraphClient();
+            const filters = [];
+            // Build filters quickly
+            if (criteria.from) {
+                const escapedFrom = this.escapeODataValue(criteria.from);
+                filters.push(`contains(from/emailAddress/address,'${escapedFrom}') or contains(from/emailAddress/name,'${escapedFrom}')`);
+            }
+            if (criteria.to) {
+                const escapedTo = this.escapeODataValue(criteria.to);
+                filters.push(`toRecipients/any(r:contains(r/emailAddress/address,'${escapedTo}'))`);
+            }
+            if (criteria.cc) {
+                const escapedCc = this.escapeODataValue(criteria.cc);
+                filters.push(`ccRecipients/any(r:contains(r/emailAddress/address,'${escapedCc}'))`);
+            }
+            if (criteria.subject) {
+                const escapedSubject = this.escapeODataValue(criteria.subject);
+                filters.push(`contains(subject,'${escapedSubject}')`);
+            }
+            if (criteria.after) {
+                const afterDate = this.formatDateForOData(criteria.after);
+                filters.push(`receivedDateTime ge '${afterDate}'`);
+            }
+            if (criteria.before) {
+                const beforeDate = this.formatDateForOData(criteria.before);
+                filters.push(`receivedDateTime le '${beforeDate}'`);
+            }
+            if (criteria.isUnread !== undefined) {
+                filters.push(`isRead eq ${!criteria.isUnread}`);
+            }
+            if (criteria.importance) {
+                filters.push(`importance eq '${criteria.importance}'`);
+            }
+            if (criteria.hasAttachment !== undefined) {
+                filters.push(`hasAttachments eq ${criteria.hasAttachment}`);
+            }
+            // Build API call
+            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(criteria.maxResults || 50);
+            // Apply filters
+            if (filters.length > 0) {
+                const filterString = filters.join(' and ');
+                logger.log(`🔍 Fast OData filter: ${filterString}`);
+                apiCall = apiCall.filter(filterString);
+            }
+            // Apply folder filter using optimized search
+            if (criteria.folder) {
+                logger.log(`🔍 Using optimized folder search (FAST mode) for: ${criteria.folder}`);
+                return await this.performOptimizedFolderSearch(criteria, criteria.maxResults || 50);
+            }
+            const result = await apiCall.get();
+            const messages = result.value?.map((email) => this.mapEmailResult(email)) || [];
+            logger.log(`📧 Fast OData search returned ${messages.length} results`);
+            return messages;
+        }
+        catch (error) {
+            logger.log(`❌ Fast OData search failed: ${error}`);
+            return [];
+        }
+    }
+    /**
+     * Fast basic search - optimized for speed
+     */
+    async performBasicSearchFast(criteria) {
+        logger.log('🔄 Using fast 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)) || [];
+        // Apply minimal filtering for speed
+        if (criteria.from || criteria.to || criteria.subject) {
+            messages = this.applyBasicFiltering(messages, criteria);
+        }
+        return {
+            messages,
+            hasMore: !!result['@odata.nextLink']
+        };
+    }
+    /**
+     * Basic filtering for fast search
+     */
+    applyBasicFiltering(messages, criteria) {
+        return messages.filter(message => {
+            // Simple text matching
+            if (criteria.from) {
+                const fromText = `${message.from.name} ${message.from.address}`.toLowerCase();
+                if (!fromText.includes(criteria.from.toLowerCase()))
+                    return false;
+            }
+            if (criteria.to) {
+                const toText = message.toRecipients.map(r => `${r.name} ${r.address}`).join(' ').toLowerCase();
+                if (!toText.includes(criteria.to.toLowerCase()))
+                    return false;
+            }
+            if (criteria.subject) {
+                if (!message.subject.toLowerCase().includes(criteria.subject.toLowerCase()))
+                    return false;
+            }
+            return true;
+        });
+    }
     /**
      * Search emails in batches of 50, looping up to 5 times to get more results efficiently
      */
+    /**
+     * GRAPH API COMPLIANT BATCH SEARCH - Respects Microsoft's strict limitations
+     * Uses the same compliant strategy as regular search but in batches
+     */
     async searchEmailsBatched(criteria = {}, batchSize = 50, maxBatches = 5) {
         return await this.executeWithAuth(async () => {
             const graphClient = await this.getGraphClient();
-            logger.log(`🔍 Starting batched email search: ${batchSize} per batch, max ${maxBatches} batches`);
+            logger.log(`🔍 Starting FAST batched email search: ${batchSize} per batch, max ${maxBatches} batches`);
             logger.log(`🔍 Search criteria:`, JSON.stringify(criteria, null, 2));
             const allMessages = [];
             let currentBatch = 0;
             let hasMoreResults = true;
             const startTime = Date.now();
-            const batchTimeout = 2 * 60 * 1000; // 2 minutes per batch
+            const batchTimeout = 30 * 1000; // 30 seconds per batch (much faster)
             try {
                 while (currentBatch < maxBatches && hasMoreResults && (Date.now() - startTime) < batchTimeout) {
                     currentBatch++;
                     logger.log(`🔍 Processing batch ${currentBatch}/${maxBatches}`);
-                    // Create criteria for this batch
+                    // Create criteria for this batch with FAST search strategy
                     const batchCriteria = {
                         ...criteria,
                         maxResults: batchSize
                     };
-                    // Search for this batch
-                    const batchResult = await this.searchEmails(batchCriteria);
-                    const batchMessages = batchResult.messages;
+                    // Use FAST search - only try the most reliable method first
+                    let batchMessages = [];
+                    try {
+                        // Strategy 1: Fast OData filter search (most reliable and fastest)
+                        logger.log(`🔍 Batch ${currentBatch}: Using fast OData filter search`);
+                        batchMessages = await this.performFilteredSearchFast(batchCriteria);
+                        if (batchMessages.length === 0) {
+                            // Strategy 2: Quick basic search fallback
+                            logger.log(`🔍 Batch ${currentBatch}: Using quick basic search fallback`);
+                            const basicResult = await this.performBasicSearchFast(batchCriteria);
+                            batchMessages = basicResult.messages;
+                        }
+                    }
+                    catch (error) {
+                        logger.log(`⚠️ Batch ${currentBatch} search failed, trying basic search: ${error}`);
+                        try {
+                            const basicResult = await this.performBasicSearchFast(batchCriteria);
+                            batchMessages = basicResult.messages;
+                        }
+                        catch (basicError) {
+                            logger.log(`❌ Batch ${currentBatch} basic search also failed: ${basicError}`);
+                            break;
+                        }
+                    }
                     logger.log(`📧 Batch ${currentBatch}: Found ${batchMessages.length} results`);
                     if (batchMessages.length > 0) {
                         // Add new messages (avoid duplicates)
@@ -2977,20 +3158,20 @@ ${originalBodyContent}
                         allMessages.push(...newMessages);
                         logger.log(`📧 Batch ${currentBatch}: Added ${newMessages.length} new unique messages (total: ${allMessages.length})`);
                         // Check if we have more results
-                        hasMoreResults = batchResult.hasMore && batchMessages.length === batchSize;
+                        hasMoreResults = batchMessages.length === batchSize;
                     }
                     else {
                         // No more results found
                         hasMoreResults = false;
                         logger.log(`📧 Batch ${currentBatch}: No more results found`);
                     }
-                    // Small delay between batches to avoid rate limiting
+                    // Shorter delay between batches for faster performance
                     if (hasMoreResults && currentBatch < maxBatches) {
-                        await new Promise(resolve => setTimeout(resolve, 1000));
+                        await new Promise(resolve => setTimeout(resolve, 500)); // Reduced to 500ms
                     }
                 }
                 const totalTime = (Date.now() - startTime) / 1000;
-                logger.log(`🔍 Batched search completed: ${allMessages.length} total results from ${currentBatch} batches in ${totalTime} seconds`);
+                logger.log(`🔍 FAST batched search completed: ${allMessages.length} total results from ${currentBatch} batches in ${totalTime} seconds`);
                 return {
                     messages: allMessages,
                     hasMore: hasMoreResults,
@@ -2998,7 +3179,7 @@ ${originalBodyContent}
                 };
             }
             catch (error) {
-                logger.error('Error in batched email search:', error);
+                logger.error('Error in fast batched email search:', error);
                 return {
                     messages: allMessages,
                     hasMore: false,
@@ -3007,5 +3188,404 @@ ${originalBodyContent}
             }
         }, 'searchEmailsBatched');
     }
+    /**
+     * NATIVE MICROSOFT GRAPH JSON BATCHING
+     * Uses the official $batch endpoint to combine up to 20 requests into a single HTTP call
+     * Based on: https://learn.microsoft.com/en-us/graph/json-batching
+     */
+    async batchRequests(requests) {
+        return await this.executeWithAuth(async () => {
+            if (requests.length === 0) {
+                return new Map();
+            }
+            if (requests.length > 20) {
+                throw new Error('Microsoft Graph batch limit is 20 requests. Use multiple batches for more requests.');
+            }
+            const graphClient = await this.getGraphClient();
+            logger.log(`🔄 NATIVE BATCH: Processing ${requests.length} requests in single HTTP call`);
+            const batchRequest = {
+                requests: requests.map(req => ({
+                    id: req.id,
+                    method: req.method.toUpperCase(),
+                    url: req.url.startsWith('/') ? req.url : `/${req.url}`,
+                    headers: req.headers || {},
+                    body: req.body,
+                    dependsOn: req.dependsOn || []
+                }))
+            };
+            const startTime = Date.now();
+            const batchResponse = await graphClient
+                .api('/$batch')
+                .post(batchRequest);
+            const processingTime = Date.now() - startTime;
+            logger.log(`📊 NATIVE BATCH: Completed ${requests.length} requests in ${processingTime}ms (avg: ${(processingTime / requests.length).toFixed(2)}ms per request)`);
+            // Process responses into a Map for easy access
+            const results = new Map();
+            if (batchResponse.responses) {
+                for (const response of batchResponse.responses) {
+                    if (response.status >= 200 && response.status < 300) {
+                        results.set(response.id, {
+                            success: true,
+                            data: response.body,
+                            status: response.status,
+                            headers: response.headers
+                        });
+                    }
+                    else {
+                        results.set(response.id, {
+                            success: false,
+                            error: response.body,
+                            status: response.status,
+                            headers: response.headers
+                        });
+                    }
+                }
+            }
+            return results;
+        }, 'batchRequests');
+    }
+    /**
+     * Get multiple emails efficiently using native JSON batching
+     * Replaces the current manual batching approach
+     */
+    async getEmailsBatch(messageIds, includeAttachments = false) {
+        if (messageIds.length === 0) {
+            return [];
+        }
+        const emails = [];
+        const selectFields = 'id,subject,from,toRecipients,ccRecipients,receivedDateTime,sentDateTime,bodyPreview,isRead,hasAttachments,importance,conversationId,parentFolderId,webLink';
+        // Process in batches of 20 (Graph API limit)
+        for (let i = 0; i < messageIds.length; i += 20) {
+            const batchIds = messageIds.slice(i, i + 20);
+            // Create batch requests
+            const requests = batchIds.map((id, index) => ({
+                id: `email_${i + index}`,
+                method: 'GET',
+                url: `/me/messages/${id}?$select=${selectFields}`
+            }));
+            // Add attachment requests if needed
+            if (includeAttachments) {
+                const attachmentRequests = batchIds.map((id, index) => ({
+                    id: `attachments_${i + index}`,
+                    method: 'GET',
+                    url: `/me/messages/${id}/attachments`,
+                    dependsOn: [`email_${i + index}`] // Only run if email request succeeds
+                }));
+                requests.push(...attachmentRequests);
+            }
+            // Execute batch
+            const batchResults = await this.batchRequests(requests);
+            // Process email results
+            for (let j = 0; j < batchIds.length; j++) {
+                const emailResult = batchResults.get(`email_${i + j}`);
+                if (emailResult?.success) {
+                    const emailInfo = this.mapEmailResult(emailResult.data);
+                    // Add attachments if requested
+                    if (includeAttachments) {
+                        const attachmentResult = batchResults.get(`attachments_${i + j}`);
+                        if (attachmentResult?.success) {
+                            emailInfo.attachments = attachmentResult.data.value?.map((att) => ({
+                                id: att.id,
+                                name: att.name,
+                                size: att.size,
+                                contentType: att.contentType,
+                                isInline: att.isInline || false
+                            })) || [];
+                        }
+                    }
+                    emails.push(emailInfo);
+                }
+                else {
+                    logger.log(`❌ Failed to get email ${batchIds[j]}: ${emailResult?.error?.message || 'Unknown error'}`);
+                }
+            }
+        }
+        return emails;
+    }
+    /**
+     * Perform multiple email operations in a single batch
+     * Examples: mark multiple emails as read, move multiple emails, etc.
+     */
+    async batchEmailOperations(operations) {
+        const requests = operations.map(op => {
+            switch (op.operation) {
+                case 'mark':
+                    return {
+                        id: op.id,
+                        method: 'PATCH',
+                        url: `/me/messages/${op.messageId}`,
+                        headers: { 'Content-Type': 'application/json' },
+                        body: { isRead: op.params?.isRead ?? true }
+                    };
+                case 'move':
+                    return {
+                        id: op.id,
+                        method: 'POST',
+                        url: `/me/messages/${op.messageId}/move`,
+                        headers: { 'Content-Type': 'application/json' },
+                        body: { destinationId: op.params?.destinationFolderId }
+                    };
+                case 'delete':
+                    return {
+                        id: op.id,
+                        method: 'DELETE',
+                        url: `/me/messages/${op.messageId}`
+                    };
+                default:
+                    throw new Error(`Unknown operation: ${op.operation}`);
+            }
+        });
+        const batchResults = await this.batchRequests(requests);
+        // Convert to operation results
+        const results = new Map();
+        for (const [id, result] of batchResults) {
+            results.set(id, {
+                success: result.success,
+                error: result.success ? undefined : result.error?.message || 'Unknown error'
+            });
+        }
+        return results;
+    }
+    /**
+     * Enhanced folder and email info fetching using batching
+     * Gets folder info and recent emails in parallel
+     */
+    async getFolderWithRecentEmails(folderId, emailCount = 10) {
+        const requests = [
+            {
+                id: 'folder_info',
+                method: 'GET',
+                url: `/me/mailFolders/${folderId}?$select=id,displayName,totalItemCount,unreadItemCount,parentFolderId`
+            },
+            {
+                id: 'recent_emails',
+                method: 'GET',
+                url: `/me/mailFolders/${folderId}/messages?$select=id,subject,from,receivedDateTime,isRead,hasAttachments&$orderby=receivedDateTime desc&$top=${emailCount}`
+            }
+        ];
+        const batchResults = await this.batchRequests(requests);
+        const folderResult = batchResults.get('folder_info');
+        const emailsResult = batchResults.get('recent_emails');
+        return {
+            folder: folderResult?.success ? folderResult.data : null,
+            emails: emailsResult?.success ?
+                (emailsResult.data.value?.map((email) => this.mapEmailResult(email)) || []) :
+                []
+        };
+    }
+    /**
+     * Perform optimized folder search for large folders
+     */
+    async performOptimizedFolderSearch(criteria, maxResults) {
+        try {
+            const graphClient = await this.getGraphClient();
+            // First, find the folder
+            const folders = await this.findFolderByName(criteria.folder);
+            if (folders.length === 0) {
+                logger.log(`❌ Folder not found: ${criteria.folder}`);
+                throw new Error(`Folder "${criteria.folder}" not found. Available folders can be checked with list_folders tool.`);
+            }
+            const targetFolder = folders[0];
+            logger.log(`🔍 Searching in folder: ${targetFolder.displayName} (${targetFolder.totalItemCount} total emails)`);
+            // Check if it's a large folder and adjust strategy
+            const isLargeFolder = targetFolder.totalItemCount > 10000;
+            if (isLargeFolder) {
+                logger.log(`⚡ Large folder detected (${targetFolder.totalItemCount} emails). Using optimized search strategy.`);
+                // For large folders, use recent-first strategy with filters
+                return await this.performLargeFolderOptimizedSearch(targetFolder, criteria, maxResults);
+            }
+            else {
+                // For smaller folders, use standard folder search
+                return await this.performStandardFolderSearch(targetFolder, criteria, maxResults);
+            }
+        }
+        catch (error) {
+            logger.error(`Error in optimized folder search:`, error);
+            throw error;
+        }
+    }
+    /**
+     * Optimized search for large folders (>10k emails)
+     */
+    async performLargeFolderOptimizedSearch(folder, criteria, maxResults) {
+        const graphClient = await this.getGraphClient();
+        // Strategy 1: Search recent emails first (last 90 days)
+        const recentDate = new Date();
+        recentDate.setDate(recentDate.getDate() - 90);
+        const recentDateStr = recentDate.toISOString().split('T')[0];
+        logger.log(`🔍 Phase 1: Searching recent emails (since ${recentDateStr}) in large folder`);
+        let apiCall = graphClient
+            .api(`/me/mailFolders/${folder.id}/messages`)
+            .select('id,subject,from,toRecipients,ccRecipients,receivedDateTime,sentDateTime,bodyPreview,isRead,hasAttachments,importance,conversationId,parentFolderId,webLink')
+            .orderby('receivedDateTime desc')
+            .top(Math.min(maxResults * 2, 500)); // Get more for filtering
+        // Build filters for better performance
+        const filters = [`receivedDateTime ge '${recentDateStr}T00:00:00Z'`];
+        if (criteria.from) {
+            const escapedFrom = this.escapeODataValue(criteria.from);
+            if (criteria.from.includes('@')) {
+                filters.push(`from/emailAddress/address eq '${escapedFrom}'`);
+            }
+            else {
+                filters.push(`contains(from/emailAddress/name,'${escapedFrom}')`);
+            }
+        }
+        if (criteria.subject) {
+            const escapedSubject = this.escapeODataValue(criteria.subject);
+            filters.push(`contains(subject,'${escapedSubject}')`);
+        }
+        if (criteria.isUnread !== undefined) {
+            filters.push(`isRead eq ${!criteria.isUnread}`);
+        }
+        if (criteria.hasAttachment !== undefined) {
+            filters.push(`hasAttachments eq ${criteria.hasAttachment}`);
+        }
+        const filterString = filters.join(' and ');
+        logger.log(`🔍 Large folder filter: ${filterString}`);
+        apiCall = apiCall.filter(filterString);
+        const result = await apiCall.get();
+        let messages = result.value?.map((email) => this.mapEmailResult(email)) || [];
+        // Apply additional text filtering
+        if (criteria.query) {
+            messages = messages.filter(message => {
+                const searchText = criteria.query.toLowerCase();
+                const messageText = `${message.subject} ${message.bodyPreview} ${message.from.name} ${message.from.address}`.toLowerCase();
+                return messageText.includes(searchText);
+            });
+        }
+        logger.log(`📧 Large folder search Phase 1 result: ${messages.length} emails found`);
+        // If we have enough results or found good matches, return
+        if (messages.length >= maxResults || messages.length > 5) {
+            return messages.slice(0, maxResults);
+        }
+        // Strategy 2: If not enough results, search older emails (last 365 days) but with stricter filters
+        logger.log(`🔍 Phase 2: Expanding search to older emails with stricter criteria`);
+        const olderDate = new Date();
+        olderDate.setDate(olderDate.getDate() - 365);
+        const olderDateStr = olderDate.toISOString().split('T')[0];
+        let olderApiCall = graphClient
+            .api(`/me/mailFolders/${folder.id}/messages`)
+            .select('id,subject,from,toRecipients,ccRecipients,receivedDateTime,sentDateTime,bodyPreview,isRead,hasAttachments,importance,conversationId,parentFolderId,webLink')
+            .orderby('receivedDateTime desc')
+            .top(300);
+        // More restrictive filters for older search
+        const olderFilters = [
+            `receivedDateTime ge '${olderDateStr}T00:00:00Z'`,
+            `receivedDateTime lt '${recentDateStr}T00:00:00Z'`
+        ];
+        // Must have at least one specific criteria for older search
+        if (criteria.from) {
+            const escapedFrom = this.escapeODataValue(criteria.from);
+            if (criteria.from.includes('@')) {
+                olderFilters.push(`from/emailAddress/address eq '${escapedFrom}'`);
+            }
+            else {
+                olderFilters.push(`contains(from/emailAddress/name,'${escapedFrom}')`);
+            }
+        }
+        else if (criteria.subject) {
+            const escapedSubject = this.escapeODataValue(criteria.subject);
+            olderFilters.push(`contains(subject,'${escapedSubject}')`);
+        }
+        else {
+            // If no specific sender/subject, skip older search to avoid timeout
+            logger.log(`⚠️ No specific sender/subject for older search. Returning recent results only.`);
+            return messages.slice(0, maxResults);
+        }
+        if (criteria.importance) {
+            olderFilters.push(`importance eq '${criteria.importance}'`);
+        }
+        const olderFilterString = olderFilters.join(' and ');
+        logger.log(`🔍 Large folder older filter: ${olderFilterString}`);
+        olderApiCall = olderApiCall.filter(olderFilterString);
+        const olderResult = await olderApiCall.get();
+        const olderMessages = olderResult.value?.map((email) => this.mapEmailResult(email)) || [];
+        // Apply text filtering to older results
+        let filteredOlderMessages = olderMessages;
+        if (criteria.query) {
+            filteredOlderMessages = olderMessages.filter(message => {
+                const searchText = criteria.query.toLowerCase();
+                const messageText = `${message.subject} ${message.bodyPreview} ${message.from.name} ${message.from.address}`.toLowerCase();
+                return messageText.includes(searchText);
+            });
+        }
+        logger.log(`📧 Large folder search Phase 2 result: ${filteredOlderMessages.length} additional emails found`);
+        // Combine results and avoid duplicates
+        const allMessages = [...messages];
+        for (const olderMessage of filteredOlderMessages) {
+            if (!allMessages.some(existing => existing.id === olderMessage.id)) {
+                allMessages.push(olderMessage);
+            }
+        }
+        return allMessages.slice(0, maxResults);
+    }
+    /**
+     * Standard search for smaller folders (<10k emails)
+     */
+    async performStandardFolderSearch(folder, criteria, maxResults) {
+        const graphClient = await this.getGraphClient();
+        let apiCall = graphClient
+            .api(`/me/mailFolders/${folder.id}/messages`)
+            .select('id,subject,from,toRecipients,ccRecipients,receivedDateTime,sentDateTime,bodyPreview,isRead,hasAttachments,importance,conversationId,parentFolderId,webLink')
+            .orderby('receivedDateTime desc')
+            .top(Math.min(maxResults * 2, 999));
+        // Build filters
+        const filters = [];
+        if (criteria.from) {
+            const escapedFrom = this.escapeODataValue(criteria.from);
+            if (criteria.from.includes('@')) {
+                filters.push(`from/emailAddress/address eq '${escapedFrom}'`);
+            }
+            else {
+                filters.push(`contains(from/emailAddress/name,'${escapedFrom}')`);
+            }
+        }
+        if (criteria.to && criteria.to.includes('@')) {
+            const escapedTo = this.escapeODataValue(criteria.to);
+            filters.push(`toRecipients/any(r: r/emailAddress/address eq '${escapedTo}')`);
+        }
+        if (criteria.cc && criteria.cc.includes('@')) {
+            const escapedCc = this.escapeODataValue(criteria.cc);
+            filters.push(`ccRecipients/any(r: r/emailAddress/address eq '${escapedCc}')`);
+        }
+        if (criteria.subject) {
+            const escapedSubject = this.escapeODataValue(criteria.subject);
+            filters.push(`contains(subject,'${escapedSubject}')`);
+        }
+        if (criteria.after) {
+            const afterDate = this.formatDateForOData(criteria.after);
+            filters.push(`receivedDateTime ge '${afterDate}'`);
+        }
+        if (criteria.before) {
+            const beforeDate = this.formatDateForOData(criteria.before);
+            filters.push(`receivedDateTime le '${beforeDate}'`);
+        }
+        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) {
+            const filterString = filters.join(' and ');
+            logger.log(`🔍 Standard folder filter: ${filterString}`);
+            apiCall = apiCall.filter(filterString);
+        }
+        const result = await apiCall.get();
+        let messages = result.value?.map((email) => this.mapEmailResult(email)) || [];
+        // Apply additional text filtering
+        if (criteria.query) {
+            messages = messages.filter(message => {
+                const searchText = criteria.query.toLowerCase();
+                const messageText = `${message.subject} ${message.bodyPreview} ${message.from.name} ${message.from.address}`.toLowerCase();
+                return messageText.includes(searchText);
+            });
+        }
+        logger.log(`📧 Standard folder search result: ${messages.length} emails found`);
+        return messages.slice(0, maxResults);
+    }
 }
 export const ms365Operations = new MS365Operations();