ms365-mcp-server 1.1.15 → 1.1.16

package/dist/index.js

@@ -67,7 +67,7 @@ function parseArgs() {
 }
 const server = new Server({
     name: "ms365-mcp-server",
-    version: "1.1.15"
+    version: "1.1.16"
 }, {
     capabilities: {
         resources: {
@@ -88,7 +88,7 @@ const server = new Server({
         }
     }
 });
-logger.log('Server started with version 1.1.14');
+logger.log('Server started with version 1.1.16');
 // Set up the resource listing request handler
 server.setRequestHandler(ListResourcesRequestSchema, async () => {
     logger.log('Received list resources request');

package/dist/utils/ms365-operations.js

@@ -1007,83 +1007,42 @@ ${originalBodyContent}
             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 maxAttempts = 3; // Reduced from 6 to 3 for faster performance
+            // Add timeout mechanism (2 minutes max - much faster)
+            const searchTimeout = 2 * 60 * 1000; // 2 minutes
             const startTime = Date.now();
-            logger.log(`🔍 Starting persistent search with criteria: ${JSON.stringify(criteria)}`);
+            logger.log(`🔍 Starting FAST 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) - Get ALL results
+                // Strategy 1: Use FAST OData filter search (most reliable and fastest)
                 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);
+                    logger.log(`🔍 Attempt ${searchAttempts}: Using FAST OData filter search`);
+                    const filterResults = await this.performFilteredSearchFast(criteria);
                     allMessages.push(...filterResults);
                     if (allMessages.length > 0) {
-                        logger.log(`✅ Found ${allMessages.length} results with OData filter search`);
+                        logger.log(`✅ Found ${allMessages.length} results with FAST 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)
+                // Strategy 2: Use FAST basic search fallback
                 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);
+                    logger.log(`🔍 Attempt ${searchAttempts}: Using FAST basic search fallback`);
+                    const basicResult = await this.performBasicSearchFast(criteria);
+                    allMessages.push(...basicResult.messages);
                     if (allMessages.length > 0) {
-                        logger.log(`✅ Found ${allMessages.length} results with partial text search`);
+                        logger.log(`✅ Found ${allMessages.length} results with FAST basic search`);
                     }
                 }
-                // Strategy 7: Fallback to basic search with ALL results
+                // Strategy 3: Quick partial search if still no 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);
+                    logger.log(`🔍 Attempt ${searchAttempts}: Using quick partial search`);
+                    const partialResults = await this.performPartialTextSearch(criteria, criteria.maxResults || 50);
+                    allMessages.push(...partialResults);
                     if (allMessages.length > 0) {
-                        logger.log(`✅ Found ${allMessages.length} results with basic search fallback`);
+                        logger.log(`✅ Found ${allMessages.length} results with quick partial search`);
                     }
                 }
                 // Check if we hit the timeout
@@ -2945,31 +2904,176 @@ ${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 if specified
+            if (criteria.folder) {
+                const folders = await this.findFolderByName(criteria.folder);
+                if (folders.length > 0) {
+                    logger.log(`🔍 Fast folder search: ${folders[0].displayName}`);
+                    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(criteria.maxResults || 50);
+                    if (filters.length > 0) {
+                        const filterString = filters.join(' and ');
+                        apiCall = apiCall.filter(filterString);
+                    }
+                }
+            }
+            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
      */
     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 +3081,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 +3102,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,

package/package.json

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