ms365-mcp-server 1.1.14 → 1.1.15

package/dist/index.js

@@ -10,7 +10,7 @@ import path from 'path';
 import { fileURLToPath } from 'url';
 import fs from 'fs/promises';
 import crypto from 'crypto';
-import { CallToolRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ListPromptsRequestSchema, ReadResourceRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { CallToolRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ListPromptsRequestSchema, ReadResourceRequestSchema, ListResourceTemplatesRequestSchema, GetPromptRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import { logger } from './utils/api.js';
 import { MS365Operations } from './utils/ms365-operations.js';
 import { multiUserMS365Auth } from './utils/multi-user-auth.js';
@@ -67,18 +67,23 @@ function parseArgs() {
 }
 const server = new Server({
     name: "ms365-mcp-server",
-    version: "1.1.14"
+    version: "1.1.15"
 }, {
     capabilities: {
         resources: {
             read: true,
-            list: true
+            list: true,
+            templates: true
         },
         tools: {
             list: true,
             call: true
         },
         prompts: {
+            list: true,
+            get: true
+        },
+        resourceTemplates: {
             list: true
         }
     }
@@ -103,6 +108,20 @@ server.setRequestHandler(ListPromptsRequestSchema, async () => {
     logger.log('Received list prompts request');
     return { prompts: [] };
 });
+/**
+ * Handler for getting a specific prompt.
+ */
+server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+    logger.log('Received get prompt request: ' + JSON.stringify(request));
+    throw new Error("Prompt getting not implemented");
+});
+/**
+ * Handler for listing available resource templates.
+ */
+server.setRequestHandler(ListResourceTemplatesRequestSchema, async () => {
+    logger.log('Received list resource templates request');
+    return { resourceTemplates: [] };
+});
 /**
  * List available tools for interacting with Microsoft 365.
  */
@@ -201,8 +220,8 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                     },
                     action: {
                         type: "string",
-                        enum: ["read", "search", "list", "mark", "move", "delete", "search_to_me", "draft", "update_draft", "send_draft", "list_drafts", "reply_draft", "forward_draft"],
-                        description: "Action to perform: read (get email by ID), search (find emails), list (folder contents), mark (read/unread), move (to folder), delete (permanently), search_to_me (emails addressed to you), draft (create standalone draft - NOTE: Use reply_draft/forward_draft for threaded drafts), update_draft (modify existing draft), send_draft (send saved draft), list_drafts (list draft emails), reply_draft (create threaded reply draft that appears in conversation), forward_draft (create threaded forward draft that appears in conversation)"
+                        enum: ["read", "search", "search_batched", "list", "mark", "move", "delete", "search_to_me", "draft", "update_draft", "send_draft", "list_drafts", "reply_draft", "forward_draft"],
+                        description: "Action to perform: read (get email by ID), search (find emails), search_batched (find emails in batches of 50, up to 5 batches for better performance), list (folder contents), mark (read/unread), move (to folder), delete (permanently), search_to_me (emails addressed to you), draft (create standalone draft - NOTE: Use reply_draft/forward_draft for threaded drafts), update_draft (modify existing draft), send_draft (send saved draft), list_drafts (list draft emails), reply_draft (create threaded reply draft that appears in conversation), forward_draft (create threaded forward draft that appears in conversation)"
                     },
                     messageId: {
                         type: "string",
@@ -273,11 +292,24 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                     },
                     maxResults: {
                         type: "number",
-                        description: "Maximum number of results to return (default: 50, max: 200)",
-                        minimum: 1,
-                        maximum: 200,
+                        description: "Maximum number of results to return. Set to 0 or omit to get ALL matching results (safety limited to 1000). For large result sets, use specific maxResults values to avoid timeouts. Default: 50",
+                        minimum: 0,
                         default: 50
                     },
+                    batchSize: {
+                        type: "number",
+                        description: "Number of results per batch for search_batched action (default: 50)",
+                        minimum: 10,
+                        maximum: 100,
+                        default: 50
+                    },
+                    maxBatches: {
+                        type: "number",
+                        description: "Maximum number of batches for search_batched action (default: 5)",
+                        minimum: 1,
+                        maximum: 10,
+                        default: 5
+                    },
                     // Draft email parameters
                     draftTo: {
                         oneOf: [
@@ -726,6 +758,52 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                                 }
                             ]
                         };
+                    case "search_batched":
+                        const batchSize = args?.batchSize || 50;
+                        const maxBatches = args?.maxBatches || 5;
+                        logger.log(`DEBUG: Starting batched search with batchSize: ${batchSize}, maxBatches: ${maxBatches}`);
+                        const batchedSearchResults = await ms365Ops.searchEmailsBatched(args, batchSize, maxBatches);
+                        logger.log(`DEBUG: Batched search results count: ${batchedSearchResults.messages.length} from ${batchedSearchResults.totalBatches} batches`);
+                        // Enhanced feedback for batched search results
+                        let batchedResponseText = `🔍 Batched Email Search Results (${batchedSearchResults.messages.length} found from ${batchedSearchResults.totalBatches} batches)`;
+                        if (batchedSearchResults.messages.length === 0) {
+                            batchedResponseText = `🔍 No emails found matching your criteria.\n\n💡 Search Tips:\n`;
+                            if (args?.from) {
+                                batchedResponseText += `• Try partial names: "${args.from.split(' ')[0]}" or "${args.from.split(' ').pop()}"\n`;
+                                batchedResponseText += `• Check spelling of sender name\n`;
+                            }
+                            if (args?.subject) {
+                                batchedResponseText += `• Try broader subject terms\n`;
+                            }
+                            if (args?.after || args?.before) {
+                                batchedResponseText += `• Try expanding date range\n`;
+                            }
+                            batchedResponseText += `• Remove some search criteria to get broader results`;
+                        }
+                        else {
+                            batchedResponseText += `\n\n${batchedSearchResults.messages.map((email, index) => {
+                                // Handle missing IDs more gracefully
+                                const emailId = email.id || 'ID_MISSING';
+                                const fromDisplay = email.from?.name ? `${email.from.name} <${email.from.address}>` : email.from?.address || 'Unknown sender';
+                                return `${index + 1}. 📧 ${email.subject || 'No subject'}\n   👤 From: ${fromDisplay}\n   📅 ${email.receivedDateTime ? new Date(email.receivedDateTime).toLocaleDateString() : 'Unknown date'}\n   ${email.isRead ? '📖 Read' : '📩 Unread'}\n   🆔 ID: ${emailId}\n`;
+                            }).join('\n')}`;
+                            if (batchedSearchResults.hasMore) {
+                                batchedResponseText += `\n💡 There are more results available. Increase maxBatches parameter to get more emails.`;
+                            }
+                            batchedResponseText += `\n\n📊 Search Summary:\n`;
+                            batchedResponseText += `• Total results: ${batchedSearchResults.messages.length}\n`;
+                            batchedResponseText += `• Batches processed: ${batchedSearchResults.totalBatches}/${maxBatches}\n`;
+                            batchedResponseText += `• Batch size: ${batchSize}\n`;
+                            batchedResponseText += `• More results available: ${batchedSearchResults.hasMore ? 'Yes' : 'No'}`;
+                        }
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: batchedResponseText
+                                }
+                            ]
+                        };
                     case "search_to_me":
                         const searchToMeResults = await ms365Ops.searchEmailsToMe(args);
                         // Process attachments for each email

package/dist/utils/ms365-operations.js

@@ -92,26 +92,70 @@ export class MS365Operations {
         this.searchCache.set(cacheKey, { results, timestamp: Date.now() });
         logger.log(`Cached results for search: ${cacheKey}`);
     }
+    /**
+     * Utility method to properly escape OData filter values
+     */
+    escapeODataValue(value) {
+        // Escape single quotes by doubling them
+        return value.replace(/'/g, "''");
+    }
+    /**
+     * Utility method to validate and format date for OData filters
+     */
+    formatDateForOData(dateString) {
+        try {
+            const date = new Date(dateString);
+            if (isNaN(date.getTime())) {
+                throw new Error(`Invalid date: ${dateString}`);
+            }
+            return date.toISOString();
+        }
+        catch (error) {
+            logger.error(`Error formatting date ${dateString}:`, error);
+            throw new Error(`Invalid date format: ${dateString}. Use YYYY-MM-DD format.`);
+        }
+    }
     /**
      * Build filter query for Microsoft Graph API
      */
     buildFilterQuery(criteria) {
         const filters = [];
         if (criteria.from) {
-            filters.push(`from/emailAddress/address eq '${criteria.from}'`);
+            // Properly escape single quotes in email addresses and names
+            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}')`);
+            }
+        }
+        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}')`);
         }
-        // Note: Cannot filter on toRecipients or ccRecipients as they are complex collections
-        // These will be handled by search API or manual filtering
         if (criteria.subject) {
-            filters.push(`contains(subject,'${criteria.subject}')`);
+            // Properly escape single quotes in subject
+            const escapedSubject = this.escapeODataValue(criteria.subject);
+            filters.push(`contains(subject,'${escapedSubject}')`);
         }
         if (criteria.after) {
-            const afterDate = new Date(criteria.after).toISOString();
-            filters.push(`receivedDateTime ge ${afterDate}`);
+            // Fix date formatting - use proper ISO format with quotes
+            const afterDate = this.formatDateForOData(criteria.after);
+            filters.push(`receivedDateTime ge '${afterDate}'`);
         }
         if (criteria.before) {
-            const beforeDate = new Date(criteria.before).toISOString();
-            filters.push(`receivedDateTime le ${beforeDate}`);
+            // Fix date formatting - use proper ISO format with quotes
+            const beforeDate = this.formatDateForOData(criteria.before);
+            filters.push(`receivedDateTime le '${beforeDate}'`);
         }
         if (criteria.hasAttachment !== undefined) {
             filters.push(`hasAttachments eq ${criteria.hasAttachment}`);
@@ -944,7 +988,7 @@ ${originalBodyContent}
         }
     }
     /**
-     * Advanced email search using Microsoft Graph Search API with KQL - Persistent search until results found
+     * Advanced email search using Microsoft Graph Search API with KQL - Returns ALL matching results
      */
     async searchEmails(criteria = {}) {
         return await this.executeWithAuth(async () => {
@@ -957,52 +1001,60 @@ ${originalBodyContent}
                 logger.log('📦 Returning cached results');
                 return cachedResults;
             }
-            const maxResults = criteria.maxResults || 50;
+            // 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;
             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`);
             try {
-                // Strategy 1: Use reliable OData filter search first (has proper IDs)
-                if (searchAttempts < maxAttempts) {
+                // 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 first`);
-                    const filterResults = await this.performFilteredSearch(criteria, maxResults * 2);
+                    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)
-                if (allMessages.length === 0 && criteria.query && searchAttempts < maxAttempts) {
+                // 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}"`);
-                    const searchResults = await this.performGraphSearch(criteria.query, maxResults * 2); // Search for more to increase chances
+                    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
-                if (allMessages.length === 0 && searchAttempts < maxAttempts) {
+                // 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}"`);
-                        const kqlResults = await this.performKQLSearch(kqlQuery, maxResults * 2);
+                        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)
-                if (allMessages.length === 0 && searchAttempts < maxAttempts) {
+                // 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}"`);
-                        const relaxedResults = await this.performKQLSearch(relaxedKQL, maxResults * 2);
+                        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`);
@@ -1010,33 +1062,34 @@ ${originalBodyContent}
                     }
                 }
                 // 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')) {
+                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 recent emails (expanded scope)
-                if (allMessages.length === 0 && searchAttempts < maxAttempts) {
+                // 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`);
-                    const partialResults = await this.performPartialTextSearch(criteria, maxResults * 4); // Very broad search
+                    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 maximum scope
-                if (allMessages.length === 0 && searchAttempts < maxAttempts) {
+                // 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 with maximum scope`);
-                    const basicResult = await this.performBasicSearch({
-                        ...criteria,
-                        maxResults: Math.max(maxResults * 5, 500) // Very large scope
-                    });
+                    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.`);
+                }
                 // Remove duplicates and apply advanced filtering
                 const uniqueMessages = this.removeDuplicateMessages(allMessages);
                 logger.log(`📧 After deduplication: ${uniqueMessages.length} unique messages`);
@@ -1045,30 +1098,31 @@ ${originalBodyContent}
                 // 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);
+                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`);
-                        const limitedMessages = finalFiltered.slice(0, maxResults);
+                        // Apply maxResults limit if specified
+                        const finalMessages = maxResults > 0 ? finalFiltered.slice(0, maxResults) : finalFiltered.slice(0, safetyLimit);
                         const searchResult = {
-                            messages: limitedMessages,
-                            hasMore: finalFiltered.length > maxResults
+                            messages: finalMessages,
+                            hasMore: maxResults > 0 ? finalFiltered.length > maxResults : finalFiltered.length > safetyLimit
                         };
                         this.setCachedResults(cacheKey, searchResult);
                         return searchResult;
                     }
                 }
-                // Limit results
-                const limitedMessages = sortedMessages.slice(0, maxResults);
+                // Apply maxResults limit if specified, otherwise return all results (with safety limit)
+                const finalMessages = maxResults > 0 ? sortedMessages.slice(0, maxResults) : sortedMessages.slice(0, safetyLimit);
                 const searchResult = {
-                    messages: limitedMessages,
-                    hasMore: sortedMessages.length > maxResults
+                    messages: finalMessages,
+                    hasMore: maxResults > 0 ? sortedMessages.length > maxResults : sortedMessages.length > safetyLimit
                 };
                 this.setCachedResults(cacheKey, searchResult);
-                logger.log(`🔍 Search completed after ${searchAttempts} attempts: ${limitedMessages.length} final results`);
-                if (limitedMessages.length === 0) {
+                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.`);
                 }
                 return searchResult;
@@ -1077,7 +1131,7 @@ ${originalBodyContent}
                 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);
+                return await this.performBasicSearchAll(criteria);
             }
         }, 'searchEmails');
     }
@@ -1184,21 +1238,33 @@ ${originalBodyContent}
             // Smart sender search - handles partial names, emails, display names
             const fromTerm = criteria.from.trim();
             if (fromTerm.includes('@')) {
-                kqlParts.push(`from:${fromTerm}`);
+                // For email addresses, escape special characters
+                const escapedFrom = fromTerm.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+                kqlParts.push(`from:${escapedFrom}`);
             }
             else {
-                // For names, search in both from field and sender
-                kqlParts.push(`(from:"${fromTerm}" OR sender:"${fromTerm}" OR from:*${fromTerm}*)`);
+                // For names, search in both from field and sender with proper escaping
+                const escapedFrom = fromTerm.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+                kqlParts.push(`(from:"${escapedFrom}" OR sender:"${escapedFrom}" OR from:*${escapedFrom}*)`);
             }
         }
         if (criteria.to) {
-            kqlParts.push(`to:${criteria.to}`);
+            const escapedTo = criteria.to.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            kqlParts.push(`to:${escapedTo}`);
         }
         if (criteria.cc) {
-            kqlParts.push(`cc:${criteria.cc}`);
+            const escapedCc = criteria.cc.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            kqlParts.push(`cc:${escapedCc}`);
         }
         if (criteria.subject) {
-            kqlParts.push(`subject:"${criteria.subject}"`);
+            // Properly escape subject terms
+            const escapedSubject = criteria.subject.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            kqlParts.push(`subject:"${escapedSubject}"`);
+        }
+        if (criteria.query) {
+            // Escape general query terms
+            const escapedQuery = criteria.query.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            kqlParts.push(`"${escapedQuery}"`);
         }
         if (criteria.hasAttachment === true) {
             kqlParts.push('hasattachment:true');
@@ -1224,7 +1290,8 @@ ${originalBodyContent}
             kqlParts.push(`received<=${beforeDate}`);
         }
         if (criteria.folder) {
-            kqlParts.push(`foldernames:"${criteria.folder}"`);
+            const escapedFolder = criteria.folder.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            kqlParts.push(`foldernames:"${escapedFolder}"`);
         }
         return kqlParts.join(' AND ');
     }
@@ -1278,11 +1345,42 @@ ${originalBodyContent}
                 .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.from) {
+                // Properly escape single quotes in email addresses and names
+                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}')`);
+                }
             }
             if (criteria.to && criteria.to.includes('@')) {
-                filters.push(`toRecipients/any(r: r/emailAddress/address eq '${criteria.to}')`);
+                // 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}')`);
+            }
+            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}'`);
             }
             if (criteria.isUnread !== undefined) {
                 filters.push(`isRead eq ${!criteria.isUnread}`);
@@ -1294,17 +1392,26 @@ ${originalBodyContent}
                 filters.push(`importance eq '${criteria.importance}'`);
             }
             if (filters.length > 0) {
-                apiCall = apiCall.filter(filters.join(' and '));
+                const filterString = filters.join(' and ');
+                logger.log(`🔍 Applying OData filter: ${filterString}`);
+                apiCall = apiCall.filter(filterString);
             }
             // Apply folder filter using specific folder API
             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);
+                    }
                 }
             }
             const result = await apiCall.get();
@@ -1314,6 +1421,7 @@ ${originalBodyContent}
         }
         catch (error) {
             logger.log(`❌ Filtered Search failed: ${error}`);
+            logger.error(`❌ Filtered Search error details:`, JSON.stringify(error, null, 2));
             return [];
         }
     }
@@ -1891,7 +1999,7 @@ ${originalBodyContent}
         }
     }
     /**
-     * Search for emails addressed to the current user (both TO and CC recipients)
+     * Search for ALL emails addressed to the current user (both TO and CC recipients)
      */
     async searchEmailsToMe(additionalCriteria = {}) {
         try {
@@ -1904,96 +2012,171 @@ ${originalBodyContent}
                 return cachedResults;
             }
             try {
-                // Start with a basic query to get emails
-                const apiCall = graphClient.api('/me/messages')
-                    .select('id,subject,from,toRecipients,ccRecipients,receivedDateTime,sentDateTime,bodyPreview,isRead,hasAttachments,importance,conversationId,parentFolderId,webLink');
-                // Add search query for user's email in TO or CC using proper syntax
-                apiCall.search(`"${userEmail}"`);
-                // Add simple filters that are supported by the API
-                if (additionalCriteria.after) {
-                    apiCall.filter(`receivedDateTime ge ${new Date(additionalCriteria.after).toISOString()}`);
-                }
-                if (additionalCriteria.before) {
-                    apiCall.filter(`receivedDateTime le ${new Date(additionalCriteria.before).toISOString()}`);
-                }
-                if (additionalCriteria.isUnread !== undefined) {
-                    apiCall.filter(`isRead eq ${!additionalCriteria.isUnread}`);
-                }
-                if (additionalCriteria.importance) {
-                    apiCall.filter(`importance eq '${additionalCriteria.importance}'`);
-                }
-                // Set page size
-                const pageSize = Math.min(additionalCriteria.maxResults || 100, 100);
-                apiCall.top(pageSize);
-                const result = await apiCall.get();
-                const 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 || '',
-                    attachments: []
-                })) || [];
+                const allMessages = [];
+                let nextLink = null;
+                let pageCount = 0;
+                const maxPages = 50; // Safety limit
+                const maxResults = additionalCriteria.maxResults || 0; // 0 means no limit
+                logger.log(`🔍 Starting searchEmailsToMe to get ALL results for user: ${userEmail}`);
+                do {
+                    pageCount++;
+                    logger.log(`🔍 searchEmailsToMe - Fetching page ${pageCount}`);
+                    // Start with a basic query to get emails
+                    const apiCall = graphClient.api('/me/messages')
+                        .select('id,subject,from,toRecipients,ccRecipients,receivedDateTime,sentDateTime,bodyPreview,isRead,hasAttachments,importance,conversationId,parentFolderId,webLink');
+                    // Add search query for user's email in TO or CC using proper syntax
+                    apiCall.search(`"${userEmail}"`);
+                    // Add simple filters that are supported by the API
+                    const filters = [];
+                    if (additionalCriteria.after) {
+                        const afterDate = this.formatDateForOData(additionalCriteria.after);
+                        filters.push(`receivedDateTime ge '${afterDate}'`);
+                    }
+                    if (additionalCriteria.before) {
+                        const beforeDate = this.formatDateForOData(additionalCriteria.before);
+                        filters.push(`receivedDateTime le '${beforeDate}'`);
+                    }
+                    if (additionalCriteria.isUnread !== undefined) {
+                        filters.push(`isRead eq ${!additionalCriteria.isUnread}`);
+                    }
+                    if (additionalCriteria.importance) {
+                        filters.push(`importance eq '${additionalCriteria.importance}'`);
+                    }
+                    if (additionalCriteria.hasAttachment !== undefined) {
+                        filters.push(`hasAttachments eq ${additionalCriteria.hasAttachment}`);
+                    }
+                    // Apply filters if any
+                    if (filters.length > 0) {
+                        const filterString = filters.join(' and ');
+                        logger.log(`🔍 Applying filters to searchEmailsToMe: ${filterString}`);
+                        apiCall.filter(filterString);
+                    }
+                    // Set page size
+                    const pageSize = Math.min(999, maxResults > 0 ? maxResults : 999);
+                    apiCall.top(pageSize);
+                    // Use nextLink if available for pagination
+                    if (nextLink) {
+                        const nextApiCall = graphClient.api(nextLink);
+                        const result = await nextApiCall.get();
+                        const 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 || '',
+                            attachments: []
+                        })) || [];
+                        allMessages.push(...messages);
+                        logger.log(`📧 searchEmailsToMe page ${pageCount}: ${messages.length} results (total: ${allMessages.length})`);
+                        // Get next page link
+                        nextLink = result['@odata.nextLink'] || null;
+                    }
+                    else {
+                        const result = await apiCall.get();
+                        const 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 || '',
+                            attachments: []
+                        })) || [];
+                        allMessages.push(...messages);
+                        logger.log(`📧 searchEmailsToMe page ${pageCount}: ${messages.length} results (total: ${allMessages.length})`);
+                        // Get next page link
+                        nextLink = result['@odata.nextLink'] || null;
+                    }
+                    // Safety check to prevent infinite loops
+                    if (pageCount >= maxPages) {
+                        logger.log(`⚠️ Reached maximum page limit (${maxPages}). Stopping pagination.`);
+                        break;
+                    }
+                    // Stop if we've reached the maxResults limit
+                    if (maxResults > 0 && allMessages.length >= maxResults) {
+                        logger.log(`✅ Reached maxResults limit (${maxResults}). Stopping pagination.`);
+                        break;
+                    }
+                } while (nextLink);
                 // Filter messages to only include those where the user is in TO or CC
-                let filteredMessages = messages.filter(message => {
+                let filteredMessages = allMessages.filter(message => {
                     const isInTo = message.toRecipients.some(recipient => recipient.address.toLowerCase() === userEmail.toLowerCase());
                     const isInCc = message.ccRecipients.some(recipient => recipient.address.toLowerCase() === userEmail.toLowerCase());
                     return isInTo || isInCc;
                 });
-                // Apply hasAttachment filter manually if specified
-                if (additionalCriteria.hasAttachment !== undefined) {
-                    filteredMessages = filteredMessages.filter(message => message.hasAttachments === additionalCriteria.hasAttachment);
-                }
-                // Sort messages by receivedDateTime in descending order
-                filteredMessages.sort((a, b) => new Date(b.receivedDateTime).getTime() - new Date(a.receivedDateTime).getTime());
-                // For emails with attachments, get attachment counts
-                for (const message of filteredMessages) {
-                    if (message.hasAttachments) {
-                        try {
-                            const attachments = await graphClient
-                                .api(`/me/messages/${message.id}/attachments`)
-                                .select('id')
-                                .get();
-                            message.attachments = new Array(attachments.value?.length || 0);
-                        }
-                        catch (error) {
-                            logger.error(`Error getting attachment count for message ${message.id}:`, error);
-                            message.attachments = [];
-                        }
-                    }
+                // Apply additional manual filtering for criteria that can't be handled by API
+                if (additionalCriteria.from) {
+                    const fromTerm = additionalCriteria.from.toLowerCase();
+                    filteredMessages = filteredMessages.filter(message => {
+                        const fromName = message.from.name.toLowerCase();
+                        const fromAddress = message.from.address.toLowerCase();
+                        return fromName.includes(fromTerm) || fromAddress.includes(fromTerm);
+                    });
+                }
+                if (additionalCriteria.subject) {
+                    const subjectTerm = additionalCriteria.subject.toLowerCase();
+                    filteredMessages = filteredMessages.filter(message => message.subject.toLowerCase().includes(subjectTerm));
                 }
+                if (additionalCriteria.query) {
+                    const queryTerm = additionalCriteria.query.toLowerCase();
+                    filteredMessages = filteredMessages.filter(message => {
+                        const searchableText = `${message.subject} ${message.bodyPreview} ${message.from.name} ${message.from.address}`.toLowerCase();
+                        return searchableText.includes(queryTerm);
+                    });
+                }
+                // Apply maxResults limit if specified
+                const finalMessages = maxResults > 0 ? filteredMessages.slice(0, maxResults) : filteredMessages;
                 const searchResult = {
-                    messages: filteredMessages,
-                    hasMore: !!result['@odata.nextLink']
+                    messages: finalMessages,
+                    hasMore: maxResults > 0 ? filteredMessages.length > maxResults : false
                 };
                 this.setCachedResults(cacheKey, searchResult);
+                logger.log(`📧 searchEmailsToMe completed: ${finalMessages.length} final results from ${filteredMessages.length} filtered (${maxResults > 0 ? 'limited' : 'ALL'})`);
                 return searchResult;
             }
             catch (error) {
-                logger.error('Error in email search:', error);
-                throw error;
+                logger.error('Error in searchEmailsToMe API call:', error);
+                // Fallback to basic search with manual filtering
+                return await this.performBasicSearchAll(additionalCriteria);
             }
         }
         catch (error) {
-            logger.error('Error searching emails addressed to me:', error);
+            logger.error('Error in searchEmailsToMe:', error);
             throw error;
         }
     }
@@ -2365,5 +2548,464 @@ ${originalBodyContent}
         const matches = shorter.split('').filter(char => longer.includes(char)).length;
         return matches / longer.length;
     }
+    /**
+     * Get ALL results using OData filter-based search with pagination
+     */
+    async performFilteredSearchAll(criteria) {
+        try {
+            const graphClient = await this.getGraphClient();
+            const allMessages = [];
+            let nextLink = null;
+            let pageCount = 0;
+            const maxPages = 50; // Safety limit to prevent infinite loops
+            do {
+                pageCount++;
+                logger.log(`🔍 Filtered Search - Fetching page ${pageCount}`);
+                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(999); // Maximum allowed per page
+                // Apply OData filters where possible
+                const filters = [];
+                if (criteria.from) {
+                    // Properly escape single quotes in email addresses and names
+                    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}')`);
+                    }
+                }
+                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}')`);
+                }
+                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}'`);
+                }
+                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(`🔍 Applying OData filter: ${filterString}`);
+                    apiCall = apiCall.filter(filterString);
+                }
+                // Apply folder filter using specific folder API
+                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);
+                        }
+                    }
+                }
+                // Use nextLink if available for pagination
+                if (nextLink) {
+                    apiCall = graphClient.api(nextLink);
+                }
+                const result = await apiCall.get();
+                const messages = result.value?.map((email) => this.mapEmailResult(email)) || [];
+                allMessages.push(...messages);
+                logger.log(`📧 Filtered Search page ${pageCount}: ${messages.length} results (total: ${allMessages.length})`);
+                // Get next page link
+                nextLink = result['@odata.nextLink'] || null;
+                // Safety check to prevent infinite loops
+                if (pageCount >= maxPages) {
+                    logger.log(`⚠️ Reached maximum page limit (${maxPages}). Stopping pagination.`);
+                    break;
+                }
+            } while (nextLink);
+            logger.log(`📧 Filtered Search completed: ${allMessages.length} total results from ${pageCount} pages`);
+            return allMessages;
+        }
+        catch (error) {
+            logger.log(`❌ Filtered Search failed: ${error}`);
+            logger.error(`❌ Filtered Search error details:`, JSON.stringify(error, null, 2));
+            return [];
+        }
+    }
+    /**
+     * Get ALL results using Microsoft Graph Search API with pagination
+     */
+    async performGraphSearchAll(query) {
+        try {
+            const graphClient = await this.getGraphClient();
+            const allMessages = [];
+            let from = 0;
+            const pageSize = 1000; // Graph Search max is 1000
+            let pageCount = 0;
+            const maxPages = 20; // Safety limit
+            do {
+                pageCount++;
+                logger.log(`🔍 Graph Search - Fetching page ${pageCount} (from: ${from})`);
+                const searchRequest = {
+                    requests: [
+                        {
+                            entityTypes: ['message'],
+                            query: {
+                                queryString: query
+                            },
+                            from: from,
+                            size: pageSize,
+                            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));
+                    }
+                }
+                allMessages.push(...messages);
+                logger.log(`📧 Graph Search page ${pageCount}: ${messages.length} results (total: ${allMessages.length})`);
+                // Check if there are more results
+                const totalHits = result.value?.[0]?.hitsContainers?.[0]?.total || 0;
+                from += pageSize;
+                // Safety check to prevent infinite loops
+                if (pageCount >= maxPages || messages.length < pageSize) {
+                    logger.log(`⚠️ Reached end of results or maximum page limit. Stopping pagination.`);
+                    break;
+                }
+            } while (true);
+            logger.log(`📧 Graph Search completed: ${allMessages.length} total results from ${pageCount} pages`);
+            return allMessages;
+        }
+        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 [];
+        }
+    }
+    /**
+     * Get ALL results using KQL search with pagination
+     */
+    async performKQLSearchAll(kqlQuery) {
+        try {
+            const graphClient = await this.getGraphClient();
+            const allMessages = [];
+            let from = 0;
+            const pageSize = 1000;
+            let pageCount = 0;
+            const maxPages = 20; // Safety limit
+            do {
+                pageCount++;
+                logger.log(`🔍 KQL Search - Fetching page ${pageCount} (from: ${from})`);
+                const searchRequest = {
+                    requests: [
+                        {
+                            entityTypes: ['message'],
+                            query: {
+                                queryString: kqlQuery
+                            },
+                            from: from,
+                            size: pageSize,
+                            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));
+                    }
+                }
+                allMessages.push(...messages);
+                logger.log(`📧 KQL Search page ${pageCount}: ${messages.length} results (total: ${allMessages.length})`);
+                // Check if there are more results
+                const totalHits = result.value?.[0]?.hitsContainers?.[0]?.total || 0;
+                from += pageSize;
+                // Safety check to prevent infinite loops
+                if (pageCount >= maxPages || messages.length < pageSize) {
+                    logger.log(`⚠️ Reached end of results or maximum page limit. Stopping pagination.`);
+                    break;
+                }
+            } while (true);
+            logger.log(`📧 KQL Search completed: ${allMessages.length} total results from ${pageCount} pages`);
+            return allMessages;
+        }
+        catch (error) {
+            logger.log(`❌ KQL Search failed: ${error}. Falling back to filter search.`);
+            return [];
+        }
+    }
+    /**
+     * Get ALL results using basic search with pagination
+     */
+    async performBasicSearchAll(criteria) {
+        logger.log('🔄 Using fallback basic search to get ALL results');
+        const graphClient = await this.getGraphClient();
+        const allMessages = [];
+        let nextLink = null;
+        let pageCount = 0;
+        const maxPages = 50; // Safety limit
+        do {
+            pageCount++;
+            logger.log(`🔍 Basic Search - Fetching page ${pageCount}`);
+            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(999);
+            // Use nextLink if available for pagination
+            if (nextLink) {
+                apiCall = graphClient.api(nextLink);
+            }
+            const result = await apiCall.get();
+            const messages = result.value?.map((email) => this.mapEmailResult(email)) || [];
+            allMessages.push(...messages);
+            logger.log(`📧 Basic Search page ${pageCount}: ${messages.length} results (total: ${allMessages.length})`);
+            // Get next page link
+            nextLink = result['@odata.nextLink'] || null;
+            // Safety check to prevent infinite loops
+            if (pageCount >= maxPages) {
+                logger.log(`⚠️ Reached maximum page limit (${maxPages}). Stopping pagination.`);
+                break;
+            }
+        } while (nextLink);
+        // Apply manual filtering to all results
+        const filteredMessages = this.applyManualFiltering(allMessages, criteria);
+        logger.log(`📧 Basic Search completed: ${filteredMessages.length} filtered results from ${allMessages.length} total emails`);
+        return {
+            messages: filteredMessages,
+            hasMore: false // We got all results
+        };
+    }
+    /**
+     * Get ALL results using partial text search with pagination
+     */
+    async performPartialTextSearchAll(criteria) {
+        try {
+            const graphClient = await this.getGraphClient();
+            const allMessages = [];
+            let nextLink = null;
+            let pageCount = 0;
+            const maxPages = 20; // Safety limit
+            do {
+                pageCount++;
+                logger.log(`🔍 Partial Text Search - Fetching page ${pageCount}`);
+                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(999);
+                // Use nextLink if available for pagination
+                if (nextLink) {
+                    apiCall = graphClient.api(nextLink);
+                }
+                const result = await apiCall.get();
+                const messages = result.value?.map((email) => this.mapEmailResult(email)) || [];
+                allMessages.push(...messages);
+                logger.log(`📧 Partial Text Search page ${pageCount}: ${messages.length} results (total: ${allMessages.length})`);
+                // Get next page link
+                nextLink = result['@odata.nextLink'] || null;
+                // Safety check to prevent infinite loops
+                if (pageCount >= maxPages) {
+                    logger.log(`⚠️ Reached maximum page limit (${maxPages}). Stopping pagination.`);
+                    break;
+                }
+            } while (nextLink);
+            // Apply very broad partial matching to all results
+            const partialMatches = allMessages.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 completed: ${partialMatches.length} matches from ${allMessages.length} total emails`);
+            return partialMatches;
+        }
+        catch (error) {
+            logger.log(`❌ Partial text search failed: ${error}`);
+            return [];
+        }
+    }
+    /**
+     * Get ALL results using ultra-relaxed search with pagination
+     */
+    async performUltraRelaxedSearchAll(criteria) {
+        try {
+            const graphClient = await this.getGraphClient();
+            const allEmails = [];
+            // Search across multiple folders and time ranges
+            const searches = [];
+            // Search recent emails with pagination
+            searches.push(this.getAllEmailsFromFolder(graphClient, '/me/messages'));
+            // Search sent items if looking for specific people
+            if (criteria.from || criteria.to) {
+                searches.push(this.getAllEmailsFromFolder(graphClient, '/me/mailFolders/sentitems/messages'));
+            }
+            const results = await Promise.allSettled(searches);
+            results.forEach((result, index) => {
+                if (result.status === 'fulfilled') {
+                    allEmails.push(...result.value);
+                    logger.log(`📧 Ultra-relaxed search ${index + 1} found ${result.value.length} emails`);
+                }
+            });
+            const uniqueEmails = this.removeDuplicateMessages(allEmails);
+            logger.log(`📧 Ultra-relaxed search completed: ${uniqueEmails.length} unique emails`);
+            return uniqueEmails;
+        }
+        catch (error) {
+            logger.log(`❌ Ultra-relaxed search failed: ${error}`);
+            return [];
+        }
+    }
+    /**
+     * Helper method to get all emails from a specific folder with pagination
+     */
+    async getAllEmailsFromFolder(graphClient, folderPath) {
+        const allMessages = [];
+        let nextLink = null;
+        let pageCount = 0;
+        const maxPages = 20; // Safety limit
+        do {
+            pageCount++;
+            logger.log(`🔍 Getting emails from ${folderPath} - page ${pageCount}`);
+            let apiCall = graphClient
+                .api(folderPath)
+                .select('id,subject,from,toRecipients,ccRecipients,receivedDateTime,sentDateTime,bodyPreview,isRead,hasAttachments,importance,conversationId,parentFolderId,webLink')
+                .orderby('receivedDateTime desc')
+                .top(999);
+            // Use nextLink if available for pagination
+            if (nextLink) {
+                apiCall = graphClient.api(nextLink);
+            }
+            const result = await apiCall.get();
+            const messages = result.value?.map((email) => this.mapEmailResult(email)) || [];
+            allMessages.push(...messages);
+            // Get next page link
+            nextLink = result['@odata.nextLink'] || null;
+            // Safety check to prevent infinite loops
+            if (pageCount >= maxPages) {
+                logger.log(`⚠️ Reached maximum page limit (${maxPages}). Stopping pagination.`);
+                break;
+            }
+        } while (nextLink);
+        return allMessages;
+    }
+    /**
+     * Search emails in batches of 50, looping up to 5 times to get more results efficiently
+     */
+    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(`🔍 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
+            try {
+                while (currentBatch < maxBatches && hasMoreResults && (Date.now() - startTime) < batchTimeout) {
+                    currentBatch++;
+                    logger.log(`🔍 Processing batch ${currentBatch}/${maxBatches}`);
+                    // Create criteria for this batch
+                    const batchCriteria = {
+                        ...criteria,
+                        maxResults: batchSize
+                    };
+                    // Search for this batch
+                    const batchResult = await this.searchEmails(batchCriteria);
+                    const batchMessages = batchResult.messages;
+                    logger.log(`📧 Batch ${currentBatch}: Found ${batchMessages.length} results`);
+                    if (batchMessages.length > 0) {
+                        // Add new messages (avoid duplicates)
+                        const newMessages = batchMessages.filter(msg => !allMessages.some(existing => existing.id === msg.id));
+                        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;
+                    }
+                    else {
+                        // No more results found
+                        hasMoreResults = false;
+                        logger.log(`📧 Batch ${currentBatch}: No more results found`);
+                    }
+                    // Small delay between batches to avoid rate limiting
+                    if (hasMoreResults && currentBatch < maxBatches) {
+                        await new Promise(resolve => setTimeout(resolve, 1000));
+                    }
+                }
+                const totalTime = (Date.now() - startTime) / 1000;
+                logger.log(`🔍 Batched search completed: ${allMessages.length} total results from ${currentBatch} batches in ${totalTime} seconds`);
+                return {
+                    messages: allMessages,
+                    hasMore: hasMoreResults,
+                    totalBatches: currentBatch
+                };
+            }
+            catch (error) {
+                logger.error('Error in batched email search:', error);
+                return {
+                    messages: allMessages,
+                    hasMore: false,
+                    totalBatches: currentBatch
+                };
+            }
+        }, 'searchEmailsBatched');
+    }
 }
 export const ms365Operations = new MS365Operations();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ms365-mcp-server",
-  "version": "1.1.14",
+  "version": "1.1.15",
   "description": "Microsoft 365 MCP Server for managing Microsoft 365 email through natural language interactions with full OAuth2 authentication support",
   "main": "dist/index.js",
   "type": "module",