ms365-mcp-server 1.1.11 → 1.1.13

package/dist/index.js

@@ -67,7 +67,7 @@ function parseArgs() {
 }
 const server = new Server({
     name: "ms365-mcp-server",
-    version: "1.1.11"
+    version: "1.1.13"
 }, {
     capabilities: {
         resources: {
@@ -83,6 +83,7 @@ const server = new Server({
         }
     }
 });
+logger.log('Server started with version 1.1.13');
 // Set up the resource listing request handler
 server.setRequestHandler(ListResourcesRequestSchema, async () => {
     logger.log('Received list resources request');
@@ -185,7 +186,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
         },
         {
             name: "manage_email",
-            description: "UNIFIED EMAIL MANAGEMENT: Read, search, list, mark, move, or delete emails. Combines all email operations in one powerful tool. Supports intelligent partial name matching, folder management, and advanced search criteria.",
+            description: "UNIFIED EMAIL MANAGEMENT: Read, search, list, mark, move, or delete emails. Combines all email operations in one powerful tool. Supports intelligent partial name matching, folder management, and advanced search criteria. IMPORTANT: Use 'reply_draft' or 'forward_draft' actions (not 'draft') to create threaded drafts that appear in email conversations.",
             inputSchema: {
                 type: "object",
                 properties: {
@@ -196,7 +197,7 @@ 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/save draft), update_draft (modify existing draft), send_draft (send saved draft), list_drafts (list draft emails), reply_draft (create reply draft), forward_draft (create 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)"
                     },
                     messageId: {
                         type: "string",
@@ -631,6 +632,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 }
             // ============ UNIFIED EMAIL MANAGEMENT TOOL ============
             case "manage_email":
+                // Debug logging for parameter validation
+                logger.log('DEBUG: manage_email called with args:', JSON.stringify(args, null, 2));
                 if (ms365Config.multiUser) {
                     const userId = args?.userId;
                     if (!userId) {
@@ -644,6 +647,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     ms365Ops.setGraphClient(graphClient);
                 }
                 const emailAction = args?.action;
+                logger.log(`DEBUG: Email action: ${emailAction}`);
                 switch (emailAction) {
                     case "read":
                         if (!args?.messageId) {
@@ -681,6 +685,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         };
                     case "search":
                         const searchResults = await ms365Ops.searchEmails(args);
+                        logger.log(`DEBUG: Search results count: ${searchResults.messages.length}`);
+                        logger.log(`DEBUG: First result:`, JSON.stringify(searchResults.messages[0], null, 2));
                         // Enhanced feedback for search results
                         let responseText = `🔍 Email Search Results (${searchResults.messages.length} found)`;
                         if (searchResults.messages.length === 0) {
@@ -698,7 +704,12 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                             responseText += `• Remove some search criteria to get broader results`;
                         }
                         else {
-                            responseText += `\n\n${searchResults.messages.map((email, index) => `${index + 1}. 📧 ${email.subject}\n   👤 From: ${email.from.name} <${email.from.address}>\n   📅 ${new Date(email.receivedDateTime).toLocaleDateString()}\n   ${email.isRead ? '📖 Read' : '📩 Unread'}\n   🆔 ID: ${email.id}\n`).join('\n')}`;
+                            responseText += `\n\n${searchResults.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 (searchResults.hasMore) {
                                 responseText += `\n💡 There are more results available. Use maxResults parameter to get more emails.`;
                             }
@@ -840,6 +851,11 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         if (!args?.draftTo || !args?.draftSubject || !args?.draftBody) {
                             throw new Error("draftTo, draftSubject, and draftBody are required for draft action");
                         }
+                        // Check if this looks like a reply based on subject
+                        const isLikelyReply = args.draftSubject?.toString().toLowerCase().startsWith('re:');
+                        if (isLikelyReply) {
+                            logger.log('🔔 SUGGESTION: Consider using "reply_draft" action instead of "draft" for threaded replies that appear in conversations');
+                        }
                         const draftResult = await ms365Ops.saveDraftEmail({
                             to: args.draftTo,
                             cc: args.draftCc,
@@ -851,11 +867,16 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                             attachments: args.draftAttachments,
                             conversationId: args.conversationId
                         });
+                        let draftResponseText = `✅ Draft email saved successfully!\n📧 Subject: ${args.draftSubject}\n👥 To: ${Array.isArray(args.draftTo) ? args.draftTo.join(', ') : args.draftTo}\n🆔 Draft ID: ${draftResult.id}`;
+                        // Add helpful suggestion for threaded drafts
+                        if (isLikelyReply) {
+                            draftResponseText += `\n\n💡 TIP: This looks like a reply email. For drafts that appear in email threads, use "reply_draft" action with the original message ID instead of "draft".`;
+                        }
                         return {
                             content: [
                                 {
                                     type: "text",
-                                    text: `✅ Draft email saved successfully!\n📧 Subject: ${args.draftSubject}\n👥 To: ${Array.isArray(args.draftTo) ? args.draftTo.join(', ') : args.draftTo}\n🆔 Draft ID: ${draftResult.id}`
+                                    text: draftResponseText
                                 }
                             ]
                         };
@@ -916,7 +937,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         if (!args?.originalMessageId) {
                             throw new Error("originalMessageId is required for reply_draft action");
                         }
-                        const replyDraftResult = await ms365Ops.createReplyDraft(args.originalMessageId, args.draftBody, args.replyToAll || false);
+                        const replyDraftResult = await ms365Ops.createReplyDraft(args.originalMessageId, args.draftBody, args.replyToAll || false, args.draftBodyType || 'text');
                         return {
                             content: [
                                 {
@@ -929,7 +950,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         if (!args?.originalMessageId) {
                             throw new Error("originalMessageId is required for forward_draft action");
                         }
-                        const forwardDraftResult = await ms365Ops.createForwardDraft(args.originalMessageId, args.draftBody);
+                        const forwardDraftResult = await ms365Ops.createForwardDraft(args.originalMessageId, args.draftBody, args.draftBodyType || 'text');
                         return {
                             content: [
                                 {

package/dist/utils/ms365-operations.js

@@ -423,6 +423,54 @@ export class MS365Operations {
             throw error;
         }
     }
+    /**
+     * Verify draft threading by checking if draft appears in conversation
+     */
+    async verifyDraftThreading(draftId, originalConversationId) {
+        try {
+            const graphClient = await this.getGraphClient();
+            // Get the draft details
+            const draft = await graphClient
+                .api(`/me/messages/${draftId}`)
+                .select('id,subject,conversationId,parentFolderId,internetMessageHeaders,isDraft')
+                .get();
+            // Check if conversation IDs match
+            const conversationMatch = draft.conversationId === originalConversationId;
+            // Get all messages in the conversation to see if draft appears
+            let conversationMessages = [];
+            try {
+                const convResult = await graphClient
+                    .api('/me/messages')
+                    .filter(`conversationId eq '${originalConversationId}'`)
+                    .select('id,subject,isDraft,parentFolderId')
+                    .get();
+                conversationMessages = convResult.value || [];
+            }
+            catch (convError) {
+                logger.log(`Could not fetch conversation messages: ${convError}`);
+            }
+            const draftInConversation = conversationMessages.some((msg) => msg.id === draftId);
+            return {
+                isThreaded: conversationMatch && draftInConversation,
+                details: {
+                    draftConversationId: draft.conversationId,
+                    originalConversationId,
+                    conversationMatch,
+                    draftInConversation,
+                    draftFolder: draft.parentFolderId,
+                    conversationMessagesCount: conversationMessages.length,
+                    internetMessageHeaders: draft.internetMessageHeaders
+                }
+            };
+        }
+        catch (error) {
+            logger.error('Error verifying draft threading:', error);
+            return {
+                isThreaded: false,
+                details: { error: String(error) }
+            };
+        }
+    }
     /**
      * List draft emails
      */
@@ -474,30 +522,164 @@ export class MS365Operations {
     /**
      * Create a threaded reply draft from a specific message
      */
-    async createReplyDraft(originalMessageId, body, replyToAll = false) {
+    async createReplyDraft(originalMessageId, body, replyToAll = false, bodyType = 'text') {
         try {
             const graphClient = await this.getGraphClient();
-            // Use Microsoft Graph's createReply endpoint for proper threading
-            const endpoint = replyToAll
-                ? `/me/messages/${originalMessageId}/createReplyAll`
-                : `/me/messages/${originalMessageId}/createReply`;
-            const requestBody = {};
-            // If body is provided, include it as a comment
-            if (body) {
-                requestBody.comment = body;
-            }
-            const replyDraft = await graphClient
-                .api(endpoint)
-                .post(requestBody);
-            return {
-                id: replyDraft.id,
-                subject: replyDraft.subject,
-                conversationId: replyDraft.conversationId,
-                toRecipients: replyDraft.toRecipients?.map((r) => r.emailAddress.address),
-                ccRecipients: replyDraft.ccRecipients?.map((r) => r.emailAddress.address),
-                bodyPreview: replyDraft.bodyPreview,
-                isDraft: replyDraft.isDraft
+            logger.log(`Creating reply draft for message: ${originalMessageId}`);
+            logger.log(`Reply to all: ${replyToAll}`);
+            // First, get the original message to include its content in the reply
+            const originalMessage = await graphClient
+                .api(`/me/messages/${originalMessageId}`)
+                .select('id,subject,from,toRecipients,ccRecipients,conversationId,parentFolderId,internetMessageId,internetMessageHeaders,conversationIndex,body,sentDateTime')
+                .get();
+            // Build the complete reply body with original content
+            const originalBodyContent = originalMessage.body?.content || '';
+            const fromDisplay = originalMessage.from?.emailAddress?.name || originalMessage.from?.emailAddress?.address || '';
+            const sentDate = new Date(originalMessage.sentDateTime).toLocaleString();
+            // Helper function to escape HTML characters
+            const escapeHtml = (text) => {
+                return text
+                    .replace(/&/g, '&')
+                    .replace(/</g, '&lt;')
+                    .replace(/>/g, '&gt;')
+                    .replace(/"/g, '&quot;')
+                    .replace(/'/g, '&#x27;');
             };
+            // Helper function to convert text to HTML
+            const textToHtml = (text) => {
+                return escapeHtml(text).replace(/\n/g, '<br>');
+            };
+            // Process the user's body based on the specified type
+            let processedUserBody = body || '';
+            if (bodyType === 'text' && processedUserBody) {
+                processedUserBody = textToHtml(processedUserBody);
+            }
+            const completeReplyBody = `${processedUserBody}
+
+<br><br>
+<div style="border-left: 2px solid #ccc; padding-left: 10px; margin-top: 10px;">
+<p><strong>From:</strong> ${fromDisplay}<br>
+<strong>Sent:</strong> ${sentDate}<br>
+<strong>Subject:</strong> ${originalMessage.subject}</p>
+<hr style="border: none; border-top: 1px solid #ccc; margin: 10px 0;">
+${originalBodyContent}
+</div>`;
+            // First, try using the official Microsoft Graph createReply endpoint for proper threading
+            try {
+                const endpoint = replyToAll
+                    ? `/me/messages/${originalMessageId}/createReplyAll`
+                    : `/me/messages/${originalMessageId}/createReply`;
+                logger.log(`Using official Graph API endpoint: ${endpoint}`);
+                const replyDraft = await graphClient
+                    .api(endpoint)
+                    .post({
+                    message: {
+                        body: {
+                            contentType: 'html',
+                            content: completeReplyBody
+                        }
+                    }
+                });
+                logger.log(`Reply draft created successfully with ID: ${replyDraft.id}`);
+                logger.log(`Draft conversation ID: ${replyDraft.conversationId}`);
+                logger.log(`Draft appears as threaded reply in conversation with original content`);
+                return {
+                    id: replyDraft.id,
+                    subject: replyDraft.subject,
+                    conversationId: replyDraft.conversationId,
+                    toRecipients: replyDraft.toRecipients?.map((r) => r.emailAddress.address),
+                    ccRecipients: replyDraft.ccRecipients?.map((r) => r.emailAddress.address),
+                    bodyPreview: replyDraft.bodyPreview,
+                    isDraft: replyDraft.isDraft,
+                    parentFolderId: replyDraft.parentFolderId
+                };
+            }
+            catch (officialApiError) {
+                logger.log(`Official API failed: ${officialApiError}, trying fallback approach`);
+                logger.log(`Fallback: Creating manual reply draft with enhanced threading`);
+                logger.log(`Original message conversation ID: ${originalMessage.conversationId}`);
+                logger.log(`Original message folder: ${originalMessage.parentFolderId}`);
+                // Build proper References header from existing chain
+                let referencesHeader = originalMessage.internetMessageId || originalMessage.id;
+                if (originalMessage.internetMessageHeaders) {
+                    const existingReferences = originalMessage.internetMessageHeaders.find((h) => h.name.toLowerCase() === 'references');
+                    if (existingReferences && existingReferences.value) {
+                        referencesHeader = `${existingReferences.value} ${referencesHeader}`;
+                    }
+                }
+                const currentUserEmail = await this.getCurrentUserEmail();
+                const draftBody = {
+                    subject: originalMessage.subject?.startsWith('Re:') ? originalMessage.subject : `Re: ${originalMessage.subject}`,
+                    body: {
+                        contentType: 'html',
+                        content: completeReplyBody
+                    },
+                    conversationId: originalMessage.conversationId,
+                    internetMessageHeaders: [
+                        {
+                            name: 'X-In-Reply-To',
+                            value: originalMessage.internetMessageId || originalMessage.id
+                        },
+                        {
+                            name: 'X-References',
+                            value: referencesHeader
+                        },
+                        {
+                            name: 'X-Thread-Topic',
+                            value: originalMessage.subject?.replace(/^Re:\s*/i, '') || ''
+                        }
+                    ]
+                };
+                // Include conversation index if available for proper Outlook threading
+                if (originalMessage.conversationIndex) {
+                    draftBody.internetMessageHeaders.push({
+                        name: 'X-Thread-Index',
+                        value: originalMessage.conversationIndex
+                    });
+                }
+                // Set recipients based on reply type
+                if (replyToAll) {
+                    draftBody.toRecipients = [
+                        ...(originalMessage.from ? [{ emailAddress: originalMessage.from.emailAddress }] : []),
+                        ...(originalMessage.toRecipients || []).filter((r) => r.emailAddress.address !== currentUserEmail)
+                    ];
+                    draftBody.ccRecipients = originalMessage.ccRecipients || [];
+                }
+                else {
+                    draftBody.toRecipients = originalMessage.from ? [{ emailAddress: originalMessage.from.emailAddress }] : [];
+                }
+                // Create the fallback draft
+                const replyDraft = await graphClient
+                    .api('/me/messages')
+                    .post(draftBody);
+                logger.log(`Fallback reply draft created with ID: ${replyDraft.id}`);
+                logger.log(`Draft conversation ID: ${replyDraft.conversationId}`);
+                // Try to move the draft to the same folder as the original message for better threading
+                if (originalMessage.parentFolderId && originalMessage.parentFolderId !== 'drafts') {
+                    try {
+                        await graphClient
+                            .api(`/me/messages/${replyDraft.id}/move`)
+                            .post({
+                            destinationId: originalMessage.parentFolderId
+                        });
+                        logger.log(`Draft moved to original message folder: ${originalMessage.parentFolderId}`);
+                    }
+                    catch (moveError) {
+                        logger.log(`Could not move draft to original folder: ${moveError}`);
+                        // This is not critical, draft will remain in drafts folder
+                    }
+                }
+                return {
+                    id: replyDraft.id,
+                    subject: replyDraft.subject,
+                    conversationId: replyDraft.conversationId,
+                    toRecipients: replyDraft.toRecipients?.map((r) => r.emailAddress.address),
+                    ccRecipients: replyDraft.ccRecipients?.map((r) => r.emailAddress.address),
+                    bodyPreview: replyDraft.bodyPreview,
+                    isDraft: replyDraft.isDraft,
+                    parentFolderId: originalMessage.parentFolderId
+                };
+            }
         }
         catch (error) {
             throw new Error(`Error creating reply draft: ${error}`);
@@ -506,26 +688,145 @@ export class MS365Operations {
     /**
      * Create a threaded forward draft from a specific message
      */
-    async createForwardDraft(originalMessageId, comment) {
+    async createForwardDraft(originalMessageId, comment, bodyType = 'text') {
         try {
             const graphClient = await this.getGraphClient();
-            // Use Microsoft Graph's createForward endpoint for proper threading
-            const endpoint = `/me/messages/${originalMessageId}/createForward`;
-            const requestBody = {};
-            // If comment is provided, include it
-            if (comment) {
-                requestBody.comment = comment;
-            }
-            const forwardDraft = await graphClient
-                .api(endpoint)
-                .post(requestBody);
-            return {
-                id: forwardDraft.id,
-                subject: forwardDraft.subject,
-                conversationId: forwardDraft.conversationId,
-                bodyPreview: forwardDraft.bodyPreview,
-                isDraft: forwardDraft.isDraft
-            };
+            logger.log(`Creating forward draft for message: ${originalMessageId}`);
+            // First, try using the official Microsoft Graph createForward endpoint for proper threading
+            try {
+                logger.log(`Using official Graph API endpoint: /me/messages/${originalMessageId}/createForward`);
+                // Helper function to escape HTML characters
+                const escapeHtml = (text) => {
+                    return text
+                        .replace(/&/g, '&amp;')
+                        .replace(/</g, '&lt;')
+                        .replace(/>/g, '&gt;')
+                        .replace(/"/g, '&quot;')
+                        .replace(/'/g, '&#x27;');
+                };
+                // Helper function to convert text to HTML
+                const textToHtml = (text) => {
+                    return escapeHtml(text).replace(/\n/g, '<br>');
+                };
+                // Process the comment based on the specified type
+                let processedComment = comment || '';
+                if (bodyType === 'text' && processedComment) {
+                    processedComment = textToHtml(processedComment);
+                }
+                const forwardDraft = await graphClient
+                    .api(`/me/messages/${originalMessageId}/createForward`)
+                    .post({
+                    message: {
+                        body: {
+                            contentType: 'html',
+                            content: processedComment
+                        }
+                    }
+                });
+                logger.log(`Forward draft created successfully with ID: ${forwardDraft.id}`);
+                logger.log(`Draft conversation ID: ${forwardDraft.conversationId}`);
+                logger.log(`Draft appears as threaded forward in conversation`);
+                return {
+                    id: forwardDraft.id,
+                    subject: forwardDraft.subject,
+                    conversationId: forwardDraft.conversationId,
+                    bodyPreview: forwardDraft.bodyPreview,
+                    isDraft: forwardDraft.isDraft,
+                    parentFolderId: forwardDraft.parentFolderId
+                };
+            }
+            catch (officialApiError) {
+                logger.log(`Official API failed: ${officialApiError}, trying fallback approach`);
+                // Fallback to manual creation if the official endpoint fails
+                const originalMessage = await graphClient
+                    .api(`/me/messages/${originalMessageId}`)
+                    .select('id,subject,from,toRecipients,ccRecipients,conversationId,parentFolderId,internetMessageId,internetMessageHeaders,conversationIndex,body,sentDateTime')
+                    .get();
+                logger.log(`Fallback: Creating manual forward draft with enhanced threading`);
+                logger.log(`Original message conversation ID: ${originalMessage.conversationId}`);
+                logger.log(`Original message folder: ${originalMessage.parentFolderId}`);
+                // Build proper References header from existing chain
+                let referencesHeader = originalMessage.internetMessageId || originalMessage.id;
+                if (originalMessage.internetMessageHeaders) {
+                    const existingReferences = originalMessage.internetMessageHeaders.find((h) => h.name.toLowerCase() === 'references');
+                    if (existingReferences && existingReferences.value) {
+                        referencesHeader = `${existingReferences.value} ${referencesHeader}`;
+                    }
+                }
+                // Helper function to escape HTML characters for fallback
+                const escapeHtml = (text) => {
+                    return text
+                        .replace(/&/g, '&amp;')
+                        .replace(/</g, '&lt;')
+                        .replace(/>/g, '&gt;')
+                        .replace(/"/g, '&quot;')
+                        .replace(/'/g, '&#x27;');
+                };
+                // Helper function to convert text to HTML for fallback
+                const textToHtml = (text) => {
+                    return escapeHtml(text).replace(/\n/g, '<br>');
+                };
+                // Process the comment based on the specified type for fallback
+                let processedComment = comment || '';
+                if (bodyType === 'text' && processedComment) {
+                    processedComment = textToHtml(processedComment);
+                }
+                const forwardedBody = `${processedComment ? processedComment + '<br><br>' : ''}---------- Forwarded message ----------<br>From: ${originalMessage.from?.emailAddress?.name || originalMessage.from?.emailAddress?.address}<br>Date: ${originalMessage.sentDateTime}<br>Subject: ${originalMessage.subject}<br>To: ${originalMessage.toRecipients?.map((r) => r.emailAddress.address).join(', ')}<br><br>${originalMessage.body?.content || ''}`;
+                const draftBody = {
+                    subject: originalMessage.subject?.startsWith('Fwd:') ? originalMessage.subject : `Fwd: ${originalMessage.subject}`,
+                    body: {
+                        contentType: 'html',
+                        content: forwardedBody
+                    },
+                    conversationId: originalMessage.conversationId,
+                    internetMessageHeaders: [
+                        {
+                            name: 'X-References',
+                            value: referencesHeader
+                        },
+                        {
+                            name: 'X-Thread-Topic',
+                            value: originalMessage.subject?.replace(/^(Re:|Fwd?):\s*/i, '') || ''
+                        }
+                    ]
+                };
+                // Include conversation index if available for proper Outlook threading
+                if (originalMessage.conversationIndex) {
+                    draftBody.internetMessageHeaders.push({
+                        name: 'X-Thread-Index',
+                        value: originalMessage.conversationIndex
+                    });
+                }
+                // Create the fallback draft
+                const forwardDraft = await graphClient
+                    .api('/me/messages')
+                    .post(draftBody);
+                logger.log(`Fallback forward draft created with ID: ${forwardDraft.id}`);
+                logger.log(`Draft conversation ID: ${forwardDraft.conversationId}`);
+                // Try to move the draft to the same folder as the original message for better threading
+                if (originalMessage.parentFolderId && originalMessage.parentFolderId !== 'drafts') {
+                    try {
+                        await graphClient
+                            .api(`/me/messages/${forwardDraft.id}/move`)
+                            .post({
+                            destinationId: originalMessage.parentFolderId
+                        });
+                        logger.log(`Draft moved to original message folder: ${originalMessage.parentFolderId}`);
+                    }
+                    catch (moveError) {
+                        logger.log(`Could not move draft to original folder: ${moveError}`);
+                        // This is not critical, draft will remain in drafts folder
+                    }
+                }
+                return {
+                    id: forwardDraft.id,
+                    subject: forwardDraft.subject,
+                    conversationId: forwardDraft.conversationId,
+                    bodyPreview: forwardDraft.bodyPreview,
+                    isDraft: forwardDraft.isDraft,
+                    parentFolderId: originalMessage.parentFolderId
+                };
+            }
         }
         catch (error) {
             throw new Error(`Error creating forward draft: ${error}`);
@@ -648,10 +949,12 @@ export class MS365Operations {
     async searchEmails(criteria = {}) {
         return await this.executeWithAuth(async () => {
             const graphClient = await this.getGraphClient();
+            logger.log(`🔍 Starting email search with criteria:`, JSON.stringify(criteria, null, 2));
             // Create cache key from criteria
             const cacheKey = JSON.stringify(criteria);
             const cachedResults = this.getCachedResults(cacheKey);
             if (cachedResults) {
+                logger.log('📦 Returning cached results');
                 return cachedResults;
             }
             const maxResults = criteria.maxResults || 50;
@@ -660,8 +963,18 @@ export class MS365Operations {
             const maxAttempts = 6; // Try multiple strategies
             logger.log(`🔍 Starting persistent search with criteria: ${JSON.stringify(criteria)}`);
             try {
-                // Strategy 1: Use Microsoft Graph Search API for text-based queries
-                if (criteria.query && searchAttempts < maxAttempts) {
+                // Strategy 1: Use reliable OData filter search first (has proper IDs)
+                if (searchAttempts < maxAttempts) {
+                    searchAttempts++;
+                    logger.log(`🔍 Attempt ${searchAttempts}: Using reliable OData filter search first`);
+                    const filterResults = await this.performFilteredSearch(criteria, maxResults * 2);
+                    allMessages.push(...filterResults);
+                    if (allMessages.length > 0) {
+                        logger.log(`✅ Found ${allMessages.length} results with OData filter search`);
+                    }
+                }
+                // Strategy 2: Use Microsoft Graph Search API for text-based queries (backup)
+                if (allMessages.length === 0 && criteria.query && searchAttempts < maxAttempts) {
                     searchAttempts++;
                     logger.log(`🔍 Attempt ${searchAttempts}: Using Graph Search API for query: "${criteria.query}"`);
                     const searchResults = await this.performGraphSearch(criteria.query, maxResults * 2); // Search for more to increase chances
@@ -670,7 +983,7 @@ export class MS365Operations {
                         logger.log(`✅ Found ${allMessages.length} results with Graph Search API`);
                     }
                 }
-                // Strategy 2: Use KQL (Keyword Query Language) for advanced searches
+                // Strategy 3: Use KQL (Keyword Query Language) for advanced searches
                 if (allMessages.length === 0 && searchAttempts < maxAttempts) {
                     const kqlQuery = this.buildKQLQuery(criteria);
                     if (kqlQuery) {
@@ -683,7 +996,7 @@ export class MS365Operations {
                         }
                     }
                 }
-                // Strategy 3: Try relaxed KQL search (remove some constraints)
+                // Strategy 4: Try relaxed KQL search (remove some constraints)
                 if (allMessages.length === 0 && searchAttempts < maxAttempts) {
                     const relaxedKQL = this.buildRelaxedKQLQuery(criteria);
                     if (relaxedKQL && relaxedKQL !== this.buildKQLQuery(criteria)) {
@@ -696,17 +1009,12 @@ export class MS365Operations {
                         }
                     }
                 }
-                // Strategy 4: OData filter search with broader scope
-                if (allMessages.length === 0 && searchAttempts < maxAttempts) {
-                    searchAttempts++;
-                    logger.log(`🔍 Attempt ${searchAttempts}: Using OData filter search with broader scope`);
-                    const filterResults = await this.performFilteredSearch(criteria, maxResults * 3); // Even broader search
-                    allMessages.push(...filterResults);
-                    if (allMessages.length > 0) {
-                        logger.log(`✅ Found ${allMessages.length} results with OData filter search`);
-                    }
+                // Strategy 5: If we found results but they have UNKNOWN IDs, try to resolve them
+                if (allMessages.length > 0 && allMessages.some(msg => msg.id === 'UNKNOWN')) {
+                    logger.log(`🔍 Attempting to resolve UNKNOWN message IDs using direct message queries`);
+                    allMessages = await this.resolveUnknownMessageIds(allMessages, criteria);
                 }
-                // Strategy 5: Partial text search across recent emails (expanded scope)
+                // Strategy 6: Partial text search across recent emails (expanded scope)
                 if (allMessages.length === 0 && searchAttempts < maxAttempts) {
                     searchAttempts++;
                     logger.log(`🔍 Attempt ${searchAttempts}: Using expanded partial text search`);
@@ -716,7 +1024,7 @@ export class MS365Operations {
                         logger.log(`✅ Found ${allMessages.length} results with partial text search`);
                     }
                 }
-                // Strategy 6: Fallback to basic search with maximum scope
+                // Strategy 7: Fallback to basic search with maximum scope
                 if (allMessages.length === 0 && searchAttempts < maxAttempts) {
                     searchAttempts++;
                     logger.log(`🔍 Attempt ${searchAttempts}: Using fallback basic search with maximum scope`);
@@ -773,6 +1081,53 @@ export class MS365Operations {
             }
         }, 'searchEmails');
     }
+    /**
+     * Resolve UNKNOWN message IDs by finding messages using alternative search criteria
+     */
+    async resolveUnknownMessageIds(messages, criteria) {
+        try {
+            const graphClient = await this.getGraphClient();
+            const resolvedMessages = [];
+            for (const message of messages) {
+                if (message.id === 'UNKNOWN') {
+                    // Try to find this message using subject and sender
+                    try {
+                        const searchFilter = [];
+                        if (message.subject) {
+                            searchFilter.push(`subject eq '${message.subject.replace(/'/g, "''")}'`);
+                        }
+                        if (message.from?.address) {
+                            searchFilter.push(`from/emailAddress/address eq '${message.from.address}'`);
+                        }
+                        if (searchFilter.length > 0) {
+                            const result = await graphClient
+                                .api('/me/messages')
+                                .filter(searchFilter.join(' and '))
+                                .select('id,subject,from,toRecipients,ccRecipients,receivedDateTime,sentDateTime,bodyPreview,isRead,hasAttachments,importance,conversationId,parentFolderId,webLink')
+                                .top(1)
+                                .get();
+                            if (result.value && result.value.length > 0) {
+                                const resolvedMessage = this.mapEmailResult(result.value[0]);
+                                logger.log(`✅ Resolved UNKNOWN ID to: ${resolvedMessage.id}`);
+                                resolvedMessages.push(resolvedMessage);
+                                continue;
+                            }
+                        }
+                    }
+                    catch (resolveError) {
+                        logger.log(`⚠️ Could not resolve message ID: ${resolveError}`);
+                    }
+                }
+                // If we couldn't resolve it, keep the original message
+                resolvedMessages.push(message);
+            }
+            return resolvedMessages;
+        }
+        catch (error) {
+            logger.log(`⚠️ Error resolving unknown message IDs: ${error}`);
+            return messages; // Return original messages if resolution fails
+        }
+    }
     /**
      * Use Microsoft Graph Search API for full-text search
      */
@@ -792,21 +1147,31 @@ export class MS365Operations {
                     }
                 ]
             };
+            logger.log(`🔍 Graph Search request:`, JSON.stringify(searchRequest, null, 2));
             const result = await graphClient
                 .api('/search/query')
                 .post(searchRequest);
+            logger.log(`🔍 Graph Search raw response:`, JSON.stringify(result, null, 2));
             const messages = [];
             if (result.value?.[0]?.hitsContainers?.[0]?.hits) {
+                logger.log(`🔍 Processing ${result.value[0].hitsContainers[0].hits.length} hits`);
                 for (const hit of result.value[0].hitsContainers[0].hits) {
                     const email = hit.resource;
-                    messages.push(this.mapEmailResult(email));
+                    logger.log(`🔍 Raw email from Graph Search:`, JSON.stringify(email, null, 2));
+                    const mappedEmail = this.mapEmailResult(email);
+                    logger.log(`🔍 Mapped email:`, JSON.stringify(mappedEmail, null, 2));
+                    messages.push(mappedEmail);
                 }
             }
+            else {
+                logger.log(`🔍 No hits found in Graph Search response structure`);
+            }
             logger.log(`📧 Graph Search returned ${messages.length} results`);
             return messages;
         }
         catch (error) {
             logger.log(`❌ Graph Search failed: ${error}. Falling back to alternative search.`);
+            logger.error(`❌ Graph Search error details:`, JSON.stringify(error, null, 2));
             return [];
         }
     }
@@ -975,8 +1340,33 @@ export class MS365Operations {
      * Map email result to EmailInfo format
      */
     mapEmailResult(email) {
+        // Extract ID from various possible locations in the response
+        let emailId = email.id;
+        if (!emailId) {
+            // Try alternative ID sources
+            emailId = email['@odata.id'] ||
+                email.internetMessageId ||
+                email._id ||
+                email.messageId ||
+                email.resource?.id;
+            // If still no ID, try to extract from webLink or other fields
+            if (!emailId && email.webLink) {
+                const linkMatch = email.webLink.match(/itemid=([^&]+)/i);
+                if (linkMatch) {
+                    emailId = decodeURIComponent(linkMatch[1]);
+                }
+            }
+            // Log the raw email object for debugging when ID is missing
+            if (!emailId) {
+                logger.log('DEBUG: Email object missing ID after all attempts:', JSON.stringify(email, null, 2));
+                emailId = 'UNKNOWN';
+            }
+            else {
+                logger.log(`DEBUG: Found email ID from alternative source: ${emailId}`);
+            }
+        }
         return {
-            id: email.id,
+            id: emailId,
             subject: email.subject || '',
             from: {
                 name: email.from?.emailAddress?.name || '',

package/package.json

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