ms365-mcp-server 1.1.16 → 1.1.18

package/dist/index.js

@@ -15,8 +15,24 @@ import { logger } from './utils/api.js';
 import { MS365Operations } from './utils/ms365-operations.js';
 import { multiUserMS365Auth } from './utils/multi-user-auth.js';
 import { enhancedMS365Auth } from './utils/ms365-auth-enhanced.js';
+import { IntelligenceEngine } from './utils/intelligence-engine.js';
+import { ProactiveIntelligence } from './utils/proactive-intelligence.js';
+import { DocumentWorkflow } from './utils/document-workflow.js';
+import { ContextAwareSearch } from './utils/context-aware-search.js';
+import { LargeMailboxSearch } from './utils/large-mailbox-search.js';
+import { BatchTestRunner } from './utils/batch-test-scenarios.js';
+import { performanceMonitor } from './utils/batch-performance-monitor.js';
+import { SearchBatchPipeline } from './utils/search-batch-pipeline.js';
 // Create singleton MS365Operations instance
 const ms365Ops = new MS365Operations();
+// Create singleton intelligence services
+const intelligenceEngine = new IntelligenceEngine(ms365Ops);
+const proactiveIntelligence = new ProactiveIntelligence(ms365Ops);
+const documentWorkflow = new DocumentWorkflow();
+const contextAwareSearch = new ContextAwareSearch(ms365Ops);
+const largeMailboxSearch = new LargeMailboxSearch(ms365Ops, contextAwareSearch, intelligenceEngine, proactiveIntelligence);
+const batchTestRunner = new BatchTestRunner(ms365Ops);
+const searchBatchPipeline = new SearchBatchPipeline(ms365Ops);
 let ms365Config = {
     setupAuth: false,
     resetAuth: false,
@@ -67,7 +83,7 @@ function parseArgs() {
 }
 const server = new Server({
     name: "ms365-mcp-server",
-    version: "1.1.16"
+    version: "1.1.18"
 }, {
     capabilities: {
         resources: {
@@ -210,7 +226,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. IMPORTANT: Use 'reply_draft' or 'forward_draft' actions (not 'draft') to create threaded drafts that appear in email conversations.",
+            description: "🚀 GRAPH API COMPLIANT EMAIL MANAGEMENT: Advanced email operations with Microsoft Graph API compliance. ✅ FIXED: Separated $filter and $search operations to respect Graph API limitations. ✅ OPTIMIZED: Dynamic timeouts (30-60s), intelligent strategy selection, and proper field restrictions. 📧 Actions: search, search_to_me, list, mark, move, delete, draft operations, threading support",
             inputSchema: {
                 type: "object",
                 properties: {
@@ -467,6 +483,351 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                     }
                 }
             }
+        },
+        {
+            name: "batch_operations",
+            description: "🚀 NATIVE GRAPH BATCHING: Leverage Microsoft Graph's native JSON batching API to perform up to 20 operations in a single HTTP request. Dramatically improves performance for multiple email operations. Based on official Microsoft Graph batching documentation.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    userId: {
+                        type: "string",
+                        description: "User ID for multi-user authentication (required if using multi-user mode)"
+                    },
+                    action: {
+                        type: "string",
+                        enum: ["batch_get_emails", "batch_email_operations", "batch_folder_operations", "get_folder_with_emails"],
+                        description: "Batch action: batch_get_emails (get multiple emails efficiently), batch_email_operations (mark/move/delete multiple emails), batch_folder_operations (multiple folder operations), get_folder_with_emails (get folder info and recent emails together)"
+                    },
+                    messageIds: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "List of message IDs for batch_get_emails and batch_email_operations actions"
+                    },
+                    includeAttachments: {
+                        type: "boolean",
+                        description: "Include attachment info when getting emails (batch_get_emails action)",
+                        default: false
+                    },
+                    operations: {
+                        type: "array",
+                        items: {
+                            type: "object",
+                            properties: {
+                                id: {
+                                    type: "string",
+                                    description: "Unique ID for this operation (for tracking results)"
+                                },
+                                operation: {
+                                    type: "string",
+                                    enum: ["mark", "move", "delete"],
+                                    description: "Operation type: mark (read/unread), move (to folder), delete (permanently)"
+                                },
+                                messageId: {
+                                    type: "string",
+                                    description: "Message ID to operate on"
+                                },
+                                params: {
+                                    type: "object",
+                                    properties: {
+                                        isRead: {
+                                            type: "boolean",
+                                            description: "Mark as read (true) or unread (false) for mark operation"
+                                        },
+                                        destinationFolderId: {
+                                            type: "string",
+                                            description: "Destination folder ID for move operation"
+                                        }
+                                    },
+                                    description: "Parameters for the operation"
+                                }
+                            },
+                            required: ["id", "operation", "messageId"]
+                        },
+                        description: "List of email operations to perform in batch (max 20 operations)"
+                    },
+                    folderId: {
+                        type: "string",
+                        description: "Folder ID for get_folder_with_emails action"
+                    },
+                    emailCount: {
+                        type: "number",
+                        description: "Number of recent emails to get with folder info (default: 10, max: 50)",
+                        minimum: 1,
+                        maximum: 50,
+                        default: 10
+                    }
+                },
+                required: ["action"]
+            }
+        },
+        {
+            name: "ai_email_assistant",
+            description: "🤖 AI EMAIL ASSISTANT: GRAPH API COMPLIANT intelligent email companion with OPTIMIZED LARGE MAILBOX SUPPORT. ✅ FIXED: Proper $filter/$search separation, field restrictions, and timeout handling. Features: Dynamic timeouts (up to 3 minutes), progressive search tiers, Graph API compliance, smart fallbacks. 🚀 BEST FOR: Large mailboxes (20k+ emails), complex searches, timeout-sensitive operations.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    userId: {
+                        type: "string",
+                        description: "User ID for multi-user authentication (required if using multi-user mode)"
+                    },
+                    action: {
+                        type: "string",
+                        enum: ["search", "classify", "process_attachments"],
+                        description: "Action: 'search' (intelligent search with AI), 'classify' (smart email classification), 'process_attachments' (intelligent attachment processing)"
+                    },
+                    query: {
+                        type: "string",
+                        description: "Natural language search query (e.g., 'tax notice from few weeks', 'government emails urgent', 'related to project alpha') - required for search action"
+                    },
+                    // Search options
+                    enableCrossReference: {
+                        type: "boolean",
+                        description: "Enable cross-reference detection to find related emails (search action)",
+                        default: true
+                    },
+                    enableFuzzySearch: {
+                        type: "boolean",
+                        description: "Enable fuzzy matching for better search results (search action)",
+                        default: true
+                    },
+                    enableThreadReconstruction: {
+                        type: "boolean",
+                        description: "Enable thread reconstruction for forwarded email chains (search action)",
+                        default: true
+                    },
+                    enableContextAware: {
+                        type: "boolean",
+                        description: "Enable context-aware search with time/sender understanding (search action)",
+                        default: true
+                    },
+                    folder: {
+                        type: "string",
+                        description: "Search within specific folder (search action, default: all folders)"
+                    },
+                    corpusSize: {
+                        type: "number",
+                        description: "Number of recent emails to search through (search action, default: 200, max: 1000)",
+                        minimum: 10,
+                        maximum: 1000,
+                        default: 200
+                    },
+                    useLargeMailboxStrategy: {
+                        type: "boolean",
+                        description: "Enable intelligent multi-tier search for large mailboxes (20k+ emails) - automatically enabled for large mailboxes",
+                        default: false
+                    },
+                    timeWindowDays: {
+                        type: "number",
+                        description: "Time window in days for large mailbox search (default: 90 for optimal performance, max: 365 for comprehensive search)",
+                        minimum: 30,
+                        maximum: 1095,
+                        default: 90
+                    },
+                    // Classification options
+                    classifyAction: {
+                        type: "string",
+                        enum: ["classify_recent", "classify_folder", "classify_batch", "get_summary"],
+                        description: "Classification action: classify_recent (last 50 emails), classify_folder (specific folder), classify_batch (specific emails), get_summary (classification summary)"
+                    },
+                    folderId: {
+                        type: "string",
+                        description: "Folder ID for classify_folder action (e.g., 'inbox', 'sent')"
+                    },
+                    messageIds: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "List of message IDs for classify_batch action or specific email for processing"
+                    },
+                    category: {
+                        type: "string",
+                        enum: ["government", "tax", "legal", "financial", "healthcare", "insurance", "deadline", "invoice", "security"],
+                        description: "Filter by specific category (classify action)"
+                    },
+                    priority: {
+                        type: "string",
+                        enum: ["critical", "high", "medium", "low"],
+                        description: "Filter by priority level (classify action)"
+                    },
+                    // Attachment processing options
+                    messageId: {
+                        type: "string",
+                        description: "Email message ID containing attachments (process_attachments action)"
+                    },
+                    attachmentIds: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "Specific attachment IDs to process (process_attachments action, optional)"
+                    },
+                    autoDecrypt: {
+                        type: "boolean",
+                        description: "Attempt to automatically decrypt password-protected files (process_attachments action)",
+                        default: true
+                    },
+                    extractText: {
+                        type: "boolean",
+                        description: "Extract text content from documents (process_attachments action)",
+                        default: true
+                    },
+                    customPasswords: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "Additional passwords to try for decryption (process_attachments action)"
+                    },
+                    // General options
+                    maxResults: {
+                        type: "number",
+                        description: "Maximum number of results to return",
+                        minimum: 1,
+                        maximum: 200,
+                        default: 50
+                    }
+                },
+                required: ["action"]
+            }
+        },
+        {
+            name: "performance_testing",
+            description: "🔬 PERFORMANCE TESTING & BENCHMARKING: Comprehensive testing suite to benchmark traditional vs native batched operations. Compare performance, monitor improvements, and generate detailed reports showing HTTP call reduction and speed improvements.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    userId: {
+                        type: "string",
+                        description: "User ID for multi-user authentication (required if using multi-user mode)"
+                    },
+                    action: {
+                        type: "string",
+                        enum: ["run_tests", "benchmark_bulk_retrieval", "benchmark_bulk_operations", "benchmark_folder_operations", "benchmark_mixed_operations", "generate_report", "clear_metrics"],
+                        description: "Testing action: run_tests (comprehensive test suite), benchmark_* (specific performance tests), generate_report (create performance report), clear_metrics (reset all metrics)"
+                    },
+                    testEmailCount: {
+                        type: "number",
+                        description: "Number of emails to use for testing (default: 10, max: 20 for safety)",
+                        minimum: 5,
+                        maximum: 20,
+                        default: 10
+                    },
+                    includeAttachments: {
+                        type: "boolean",
+                        description: "Include attachment operations in bulk retrieval tests",
+                        default: true
+                    },
+                    folderId: {
+                        type: "string",
+                        description: "Folder ID to test (default: inbox)",
+                        default: "inbox"
+                    },
+                    operationType: {
+                        type: "string",
+                        enum: ["mark", "move"],
+                        description: "Type of operation for bulk operations test (default: mark)",
+                        default: "mark"
+                    },
+                    generateDetailedLog: {
+                        type: "boolean",
+                        description: "Generate detailed performance logs",
+                        default: true
+                    }
+                },
+                required: ["action"]
+            }
+        },
+        {
+            name: "search_batch_pipeline",
+            description: "🔄 SEARCH-TO-BATCH PIPELINE: Seamlessly combine search and batch operations for maximum efficiency. Find emails with search, then efficiently process them with native batching. Perfect for bulk operations on search results.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    userId: {
+                        type: "string",
+                        description: "User ID for multi-user authentication (required if using multi-user mode)"
+                    },
+                    action: {
+                        type: "string",
+                        enum: ["search_and_retrieve", "search_and_mark_read", "search_and_mark_unread", "search_and_move", "search_and_delete", "quick_workflows"],
+                        description: "Pipeline action: search_and_retrieve (search + get full details), search_and_mark_read (search + mark as read), search_and_mark_unread (search + mark as unread), search_and_move (search + move to folder), search_and_delete (search + delete), quick_workflows (pre-built workflows)"
+                    },
+                    // Search criteria
+                    query: {
+                        type: "string",
+                        description: "Search query for finding emails"
+                    },
+                    from: {
+                        type: "string",
+                        description: "Search emails from specific sender"
+                    },
+                    to: {
+                        type: "string",
+                        description: "Search emails to specific recipient"
+                    },
+                    subject: {
+                        type: "string",
+                        description: "Search emails with specific subject"
+                    },
+                    folder: {
+                        type: "string",
+                        description: "Search within specific folder"
+                    },
+                    after: {
+                        type: "string",
+                        description: "Search emails after date (YYYY-MM-DD)"
+                    },
+                    before: {
+                        type: "string",
+                        description: "Search emails before date (YYYY-MM-DD)"
+                    },
+                    hasAttachment: {
+                        type: "boolean",
+                        description: "Filter emails with attachments"
+                    },
+                    isUnread: {
+                        type: "boolean",
+                        description: "Filter for unread emails"
+                    },
+                    importance: {
+                        type: "string",
+                        enum: ["low", "normal", "high"],
+                        description: "Filter by importance level"
+                    },
+                    maxResults: {
+                        type: "number",
+                        description: "Maximum results to find and process (default: 50, max: 100)",
+                        minimum: 1,
+                        maximum: 100,
+                        default: 50
+                    },
+                    // Batch operation parameters
+                    includeAttachments: {
+                        type: "boolean",
+                        description: "Include attachments in search_and_retrieve action",
+                        default: false
+                    },
+                    destinationFolderId: {
+                        type: "string",
+                        description: "Destination folder ID for search_and_move action"
+                    },
+                    // Quick workflow parameters
+                    workflowType: {
+                        type: "string",
+                        enum: ["mark_sender_read", "move_by_subject", "delete_old", "get_attachments"],
+                        description: "Pre-built workflow type for quick_workflows action"
+                    },
+                    senderEmail: {
+                        type: "string",
+                        description: "Sender email for mark_sender_read workflow"
+                    },
+                    subjectText: {
+                        type: "string",
+                        description: "Subject text for move_by_subject workflow"
+                    },
+                    beforeDate: {
+                        type: "string",
+                        description: "Date for delete_old workflow (YYYY-MM-DD)"
+                    }
+                },
+                required: ["action"]
+            }
         }
     ];
     // Add multi-user specific tools
@@ -538,6 +899,19 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
  */
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
+    // Helper function to validate and normalize bodyType
+    const normalizeBodyType = (bodyType) => {
+        if (!bodyType)
+            return 'text';
+        const normalized = bodyType.toString().toLowerCase().trim();
+        if (normalized === 'html')
+            return 'html';
+        if (normalized === 'text')
+            return 'text';
+        // Invalid value provided - log warning and default to text
+        logger.log(`⚠️ Invalid bodyType '${bodyType}' provided. Valid values are 'text' or 'html'. Defaulting to 'text'.`);
+        return 'text';
+    };
     try {
         switch (name) {
             // ============ UNIFIED AUTHENTICATION TOOL ============
@@ -720,7 +1094,19 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                             ]
                         };
                     case "search":
-                        const searchResults = await ms365Ops.searchEmails(args);
+                        // Enhanced basic search with dynamic timeout based on search complexity
+                        const hasComplexFilters = !!(args?.query || args?.from || args?.subject || args?.after || args?.before);
+                        const baseTimeout = hasComplexFilters ? 60000 : 45000; // 60s for complex, 45s for simple
+                        const maxResults = args?.maxResults || 50;
+                        const adjustedTimeout = maxResults > 100 ? baseTimeout * 1.5 : baseTimeout; // Increase timeout for large result sets
+                        logger.log(`🔍 Search timeout set to ${adjustedTimeout / 1000}s (complex: ${hasComplexFilters}, maxResults: ${maxResults})`);
+                        const searchPromise = ms365Ops.searchEmails(args);
+                        const timeoutPromise = new Promise((_, reject) => {
+                            setTimeout(() => {
+                                reject(new Error(`Search timed out after ${adjustedTimeout / 1000} seconds. For large mailboxes or complex searches, try: (1) ai_email_assistant with useLargeMailboxStrategy: true, (2) More specific search terms, (3) Smaller maxResults (current: ${maxResults}), or (4) Narrower date ranges.`));
+                            }, adjustedTimeout);
+                        });
+                        const searchResults = await Promise.race([searchPromise, timeoutPromise]);
                         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
@@ -762,7 +1148,15 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         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);
+                        // Add timeout protection for batched searches
+                        const batchTimeout = 45000; // 45 seconds for batched searches
+                        const batchPromise = ms365Ops.searchEmailsBatched(args, batchSize, maxBatches);
+                        const batchTimeoutPromise = new Promise((_, reject) => {
+                            setTimeout(() => {
+                                reject(new Error('Batched search timed out - try using ai_email_assistant with useLargeMailboxStrategy: true for better performance with large mailboxes'));
+                            }, batchTimeout);
+                        });
+                        const batchedSearchResults = await Promise.race([batchPromise, batchTimeoutPromise]);
                         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)`;
@@ -954,7 +1348,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                             bcc: normalizeDraftEmailArray(args.draftBcc),
                             subject: args.draftSubject,
                             body: args.draftBody,
-                            bodyType: args.draftBodyType || 'text',
+                            bodyType: normalizeBodyType(args.draftBodyType),
                             importance: args.draftImportance || 'normal',
                             attachments: args.draftAttachments,
                             conversationId: args.conversationId
@@ -998,7 +1392,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         if (args.draftBody)
                             updates.body = args.draftBody;
                         if (args.draftBodyType)
-                            updates.bodyType = args.draftBodyType;
+                            updates.bodyType = normalizeBodyType(args.draftBodyType);
                         if (args.draftImportance)
                             updates.importance = args.draftImportance;
                         if (args.draftAttachments)
@@ -1039,7 +1433,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, args.draftBodyType || 'text');
+                        const replyDraftResult = await ms365Ops.createReplyDraft(args.originalMessageId, args.draftBody, args.replyToAll || false, normalizeBodyType(args.draftBodyType));
                         return {
                             content: [
                                 {
@@ -1052,7 +1446,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, args.draftBodyType || 'text');
+                        const forwardDraftResult = await ms365Ops.createForwardDraft(args.originalMessageId, args.draftBody, normalizeBodyType(args.draftBodyType));
                         return {
                             content: [
                                 {
@@ -1107,6 +1501,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         throw new Error(`Unknown contact action: ${contactAction}`);
                 }
             // ============ REMAINING ORIGINAL TOOLS ============
+            // ============ REMAINING ORIGINAL TOOLS ============
             case "send_email":
                 if (ms365Config.multiUser) {
                     const userId = args?.userId;
@@ -1144,7 +1539,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     bcc: normalizeEmailArray(args.bcc),
                     subject: args.subject,
                     body: args.body || '',
-                    bodyType: args.bodyType || 'text',
+                    bodyType: normalizeBodyType(args.bodyType),
                     replyTo: args.replyTo,
                     importance: args.importance || 'normal',
                     attachments: args.attachments || []
@@ -1311,6 +1706,724 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         }
                     ]
                 };
+            // ============ NATIVE JSON BATCHING TOOL ============
+            case "batch_operations":
+                if (ms365Config.multiUser) {
+                    const userId = args?.userId;
+                    if (!userId) {
+                        throw new Error("User ID is required in multi-user mode");
+                    }
+                    const graphClient = await multiUserMS365Auth.getGraphClientForUser(userId);
+                    ms365Ops.setGraphClient(graphClient);
+                }
+                else {
+                    const graphClient = await enhancedMS365Auth.getGraphClient();
+                    ms365Ops.setGraphClient(graphClient);
+                }
+                const batchAction = args?.action;
+                if (!batchAction) {
+                    throw new Error("Action is required for batch operations");
+                }
+                switch (batchAction) {
+                    case 'batch_get_emails':
+                        if (!args?.messageIds || !Array.isArray(args.messageIds)) {
+                            throw new Error("messageIds array is required for batch_get_emails action");
+                        }
+                        const batchEmails = await ms365Ops.getEmailsBatch(args.messageIds, args?.includeAttachments || false);
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: `🚀 Native Batch Email Results (${batchEmails.length} emails retrieved)\n\n` +
+                                        `📊 Performance: Single HTTP request for ${args.messageIds.length} emails\n\n` +
+                                        batchEmails.map((email, index) => `${index + 1}. 📧 ${email.subject}\n` +
+                                            `   👤 From: ${email.from.name} <${email.from.address}>\n` +
+                                            `   📅 ${new Date(email.receivedDateTime).toLocaleString()}\n` +
+                                            `   ${email.isRead ? '📖 Read' : '📩 Unread'}\n` +
+                                            `   🆔 ID: ${email.id}\n` +
+                                            (email.attachments?.length ? `   📎 Attachments: ${email.attachments.length}\n` : '')).join('\n') +
+                                        `\n💡 Traditional approach would require ${args.messageIds.length} separate API calls!`
+                                }
+                            ]
+                        };
+                    case 'batch_email_operations':
+                        if (!args?.operations || !Array.isArray(args.operations)) {
+                            throw new Error("operations array is required for batch_email_operations action");
+                        }
+                        if (args.operations.length > 20) {
+                            throw new Error("Maximum 20 operations allowed per batch (Microsoft Graph limit)");
+                        }
+                        const operationResults = await ms365Ops.batchEmailOperations(args.operations);
+                        let successCount = 0;
+                        let failureCount = 0;
+                        const resultText = Array.from(operationResults.entries()).map(([id, result]) => {
+                            if (result.success) {
+                                successCount++;
+                                return `✅ ${id}: Success`;
+                            }
+                            else {
+                                failureCount++;
+                                return `❌ ${id}: ${result.error}`;
+                            }
+                        }).join('\n');
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: `🚀 Native Batch Operations Results\n\n` +
+                                        `📊 Performance: ${args.operations.length} operations in single HTTP request\n` +
+                                        `✅ Successful: ${successCount}\n` +
+                                        `❌ Failed: ${failureCount}\n\n` +
+                                        `📋 Detailed Results:\n${resultText}\n\n` +
+                                        `💡 Traditional approach would require ${args.operations.length} separate API calls!`
+                                }
+                            ]
+                        };
+                    case 'get_folder_with_emails':
+                        if (!args?.folderId) {
+                            throw new Error("folderId is required for get_folder_with_emails action");
+                        }
+                        const emailCount = Math.min(args?.emailCount || 10, 50);
+                        const folderWithEmails = await ms365Ops.getFolderWithRecentEmails(args.folderId, emailCount);
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: `🚀 Native Batch Folder + Emails Results\n\n` +
+                                        `📊 Performance: Folder info + ${emailCount} emails in single HTTP request\n\n` +
+                                        `📁 Folder: ${folderWithEmails.folder?.displayName || 'Unknown'}\n` +
+                                        `   🆔 ID: ${folderWithEmails.folder?.id}\n` +
+                                        `   📧 Total Items: ${folderWithEmails.folder?.totalItemCount || 0}\n` +
+                                        `   📩 Unread: ${folderWithEmails.folder?.unreadItemCount || 0}\n\n` +
+                                        `📧 Recent Emails (${folderWithEmails.emails.length}):\n` +
+                                        folderWithEmails.emails.map((email, index) => `${index + 1}. ${email.subject}\n` +
+                                            `   👤 From: ${email.from.name}\n` +
+                                            `   📅 ${new Date(email.receivedDateTime).toLocaleDateString()}\n` +
+                                            `   ${email.isRead ? '📖' : '📩'} ${email.isRead ? 'Read' : 'Unread'}`).join('\n') +
+                                        `\n\n💡 Traditional approach would require 2 separate API calls!`
+                                }
+                            ]
+                        };
+                    default:
+                        throw new Error(`Unknown batch action: ${batchAction}`);
+                }
+            // ============ AI EMAIL ASSISTANT (MERGED TOOL) ============
+            case "ai_email_assistant":
+                if (ms365Config.multiUser) {
+                    const userId = args?.userId;
+                    if (!userId) {
+                        throw new Error("User ID is required in multi-user mode");
+                    }
+                    const graphClient = await multiUserMS365Auth.getGraphClientForUser(userId);
+                    ms365Ops.setGraphClient(graphClient);
+                }
+                else {
+                    const graphClient = await enhancedMS365Auth.getGraphClient();
+                    ms365Ops.setGraphClient(graphClient);
+                }
+                const aiAction = args?.action;
+                if (!aiAction) {
+                    throw new Error("Action is required for AI email assistant");
+                }
+                switch (aiAction) {
+                    case 'search':
+                        if (!args?.query) {
+                            throw new Error("Query is required for search action");
+                        }
+                        const searchOptions = {
+                            enableCrossReference: args?.enableCrossReference !== false,
+                            enableFuzzySearch: args?.enableFuzzySearch !== false,
+                            enableThreadReconstruction: args?.enableThreadReconstruction !== false,
+                            maxResults: args?.maxResults || 50
+                        };
+                        const searchFolder = args?.folder || 'inbox';
+                        const useLargeMailboxStrategy = args?.useLargeMailboxStrategy === true;
+                        const timeWindowDays = args?.timeWindowDays || 365;
+                        // Check if we should use large mailbox strategy
+                        if (useLargeMailboxStrategy) {
+                            // Use advanced multi-tier search for large mailboxes
+                            const largeMailboxResult = await largeMailboxSearch.search(args.query, {
+                                maxTotalResults: searchOptions.maxResults,
+                                timeWindowDays: timeWindowDays,
+                                batchSize: 300,
+                                prioritizeRecent: true
+                            });
+                            return {
+                                content: [
+                                    {
+                                        type: "text",
+                                        text: `🤖 AI Email Assistant - Large Mailbox Search Results\n\n` +
+                                            `🔍 Query: "${largeMailboxResult.query}"\n` +
+                                            `📊 Strategy: ${largeMailboxResult.searchStrategy}\n` +
+                                            `📧 Total Mailbox Size: ~${largeMailboxResult.totalEmailsInMailbox.toLocaleString()} emails\n` +
+                                            `🎯 Confidence: ${largeMailboxResult.confidence.toFixed(2)}\n` +
+                                            `⏱️ Search Time: ${largeMailboxResult.searchTime}ms\n\n` +
+                                            `🔍 Search Tiers Executed:\n${largeMailboxResult.tierResults.map(tier => `• ${tier.tier}: ${tier.emailsSearched} searched → ${tier.resultsFound} found (${tier.processingTime}ms)`).join('\n')}\n\n` +
+                                            `📧 Found ${largeMailboxResult.finalResults.length} relevant emails:\n\n` +
+                                            largeMailboxResult.finalResults.map((email, index) => `${index + 1}. ${email.subject}\n` +
+                                                `   📨 From: ${email.from.name} <${email.from.address}>\n` +
+                                                `   📅 ${new Date(email.receivedDateTime).toLocaleString()}\n` +
+                                                `   🏷️ Categories: ${email.categories?.join(', ') || 'None'}\n` +
+                                                `   ⚡ Priority: ${email.importance || 'normal'}\n`).join('\n') +
+                                            `\n💡 Recommendations:\n${largeMailboxResult.recommendations.join('\n')}`
+                                    }
+                                ]
+                            };
+                        }
+                        else {
+                            // Use standard search for smaller mailboxes
+                            const corpusSize = args?.corpusSize || 200;
+                            const emailSearchResult = await ms365Ops.searchEmails({
+                                query: '*',
+                                maxResults: Math.min(corpusSize, 1000), // Cap at 1000 for performance
+                                folder: searchFolder
+                            });
+                            if (args?.enableContextAware !== false) {
+                                // Use context-aware search
+                                const contextResults = await contextAwareSearch.search(args.query, emailSearchResult.messages);
+                                logger.log(`🔍 Searched through ${emailSearchResult.messages.length} emails from corpus of ${corpusSize}`);
+                                const limitedResults = contextResults.emails.slice(0, searchOptions.maxResults);
+                                return {
+                                    content: [
+                                        {
+                                            type: "text",
+                                            text: `🤖 AI Email Assistant - Smart Search Results\n\n` +
+                                                `🔍 Query: "${contextResults.originalQuery}"\n` +
+                                                `📊 Strategy: ${contextResults.searchStrategy}\n` +
+                                                `📧 Searched: ${emailSearchResult.messages.length} emails\n` +
+                                                `🎯 Confidence: ${contextResults.confidence.toFixed(2)}\n\n` +
+                                                `📧 Found ${limitedResults.length} relevant emails:\n\n` +
+                                                limitedResults.map((email, index) => `${index + 1}. ${email.subject}\n` +
+                                                    `   📨 From: ${email.from.name} <${email.from.address}>\n` +
+                                                    `   📅 ${new Date(email.receivedDateTime).toLocaleString()}\n` +
+                                                    `   🏷️ Categories: ${email.categories?.join(', ') || 'None'}\n` +
+                                                    `   ⚡ Priority: ${email.importance || 'normal'}\n`).join('\n') +
+                                                `\n💡 Explanation:\n${contextResults.explanation}\n\n` +
+                                                `🎯 Suggestions:\n${contextResults.suggestions.join('\n')}`
+                                        }
+                                    ]
+                                };
+                            }
+                            else {
+                                // Use intelligent search
+                                const intelligentResults = await intelligenceEngine.intelligentSearch(args.query, emailSearchResult.messages, searchOptions);
+                                logger.log(`🧠 Analyzed ${emailSearchResult.messages.length} emails from corpus of ${corpusSize}`);
+                                return {
+                                    content: [
+                                        {
+                                            type: "text",
+                                            text: `🤖 AI Email Assistant - Intelligent Search Results\n\n` +
+                                                `🔍 Query: "${args.query}"\n` +
+                                                `📧 Searched: ${emailSearchResult.messages.length} emails\n` +
+                                                `📊 Found ${intelligentResults.insights.totalEmails} results with ${intelligentResults.insights.averageConfidence.toFixed(2)} confidence\n` +
+                                                `⏱️ Processing Time: ${intelligentResults.insights.processingTime}ms\n\n` +
+                                                `📧 Results:\n${intelligentResults.results.slice(0, searchOptions.maxResults).map((email, index) => `${index + 1}. ${email.subject}\n   📨 From: ${email.from.name} <${email.from.address}>\n   📅 ${new Date(email.receivedDateTime).toLocaleString()}\n   🔗 Cross-refs: ${intelligentResults.crossReferences.get(email.id)?.length || 0}\n   📊 Threads: ${intelligentResults.threads.has(email.id) ? 'Yes' : 'No'}\n`).join('\n')}\n\n` +
+                                                `💡 Insights:\n` +
+                                                `• Total Emails: ${intelligentResults.insights.totalEmails}\n` +
+                                                `• High Priority: ${intelligentResults.insights.highPriorityEmails}\n` +
+                                                `• Thread Count: ${intelligentResults.insights.threadCount}\n` +
+                                                `• Average Confidence: ${intelligentResults.insights.averageConfidence.toFixed(2)}`
+                                        }
+                                    ]
+                                };
+                            }
+                        }
+                    case 'classify':
+                        const classifyAction = args?.classifyAction || 'classify_recent';
+                        const maxResults = args?.maxResults || 50;
+                        switch (classifyAction) {
+                            case 'classify_recent':
+                                const recentEmailsResult = await ms365Ops.searchEmails({
+                                    query: '*',
+                                    maxResults: maxResults,
+                                    folder: 'inbox'
+                                });
+                                const recentClassifications = await proactiveIntelligence.batchClassifyEmails(recentEmailsResult.messages);
+                                const recentSummary = proactiveIntelligence.generateClassificationSummary(recentClassifications);
+                                return {
+                                    content: [
+                                        {
+                                            type: "text",
+                                            text: `🤖 AI Email Assistant - Smart Classification\n\n` +
+                                                `🏷️ Recent ${maxResults} Emails Analysis:\n\n` +
+                                                `📊 Summary:\n` +
+                                                `• Total emails: ${recentSummary.totalEmails}\n` +
+                                                `• Critical: ${recentSummary.byPriority.critical || 0}\n` +
+                                                `• High: ${recentSummary.byPriority.high || 0}\n` +
+                                                `• Medium: ${recentSummary.byPriority.medium || 0}\n` +
+                                                `• Low: ${recentSummary.byPriority.low || 0}\n\n` +
+                                                `📈 Top Categories:\n${Object.entries(recentSummary.byCategory).map(([cat, count]) => `• ${cat}: ${count}`).join('\n')}\n\n` +
+                                                `🎯 AI Recommendations:\n${recentSummary.recommendedActions.join('\n')}`
+                                        }
+                                    ]
+                                };
+                            case 'get_summary':
+                                const summaryEmailsResult = await ms365Ops.searchEmails({
+                                    query: '*',
+                                    maxResults: 100,
+                                    folder: 'inbox'
+                                });
+                                const summaryClassifications = await proactiveIntelligence.batchClassifyEmails(summaryEmailsResult.messages);
+                                const summary = proactiveIntelligence.generateClassificationSummary(summaryClassifications);
+                                return {
+                                    content: [
+                                        {
+                                            type: "text",
+                                            text: `🤖 AI Email Assistant - Intelligence Summary\n\n` +
+                                                `📊 Total Emails Analyzed: ${summary.totalEmails}\n\n` +
+                                                `⚡ Priority Distribution:\n` +
+                                                `• Critical: ${summary.byPriority.critical || 0}\n` +
+                                                `• High: ${summary.byPriority.high || 0}\n` +
+                                                `• Medium: ${summary.byPriority.medium || 0}\n` +
+                                                `• Low: ${summary.byPriority.low || 0}\n\n` +
+                                                `📈 Category Distribution:\n${Object.entries(summary.byCategory).map(([cat, count]) => `• ${cat}: ${count}`).join('\n')}\n\n` +
+                                                `🎯 Top AI Recommendations:\n${summary.recommendedActions.slice(0, 5).join('\n')}`
+                                        }
+                                    ]
+                                };
+                            default:
+                                throw new Error(`Unknown classification action: ${classifyAction}`);
+                        }
+                    case 'process_attachments':
+                        if (!args?.messageId) {
+                            throw new Error("Message ID is required for attachment processing");
+                        }
+                        // Get the email and its attachments
+                        const email = await ms365Ops.getEmail(args.messageId, true);
+                        if (!email.hasAttachments || !email.attachments) {
+                            throw new Error("This email has no attachments to process");
+                        }
+                        // Filter specific attachments if requested
+                        let attachmentsToProcess = email.attachments;
+                        if (args?.attachmentIds && Array.isArray(args.attachmentIds)) {
+                            attachmentsToProcess = email.attachments.filter(att => args.attachmentIds.includes(att.id));
+                        }
+                        // Download attachments and prepare for processing
+                        const attachmentData = await Promise.all(attachmentsToProcess.map(async (att) => {
+                            const attachment = await ms365Ops.getAttachment(args.messageId, att.id);
+                            return {
+                                id: att.id,
+                                name: att.name,
+                                size: att.size,
+                                contentType: att.contentType,
+                                contentBytes: attachment.contentBytes
+                            };
+                        }));
+                        // Process attachments with document workflow
+                        const processingResults = await documentWorkflow.processEmailAttachments(email, attachmentData);
+                        // Get processing statistics
+                        const stats = documentWorkflow.getProcessingStats(processingResults);
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: `🤖 AI Email Assistant - Smart Attachment Processing\n\n` +
+                                        `📊 Statistics:\n` +
+                                        `• Total: ${stats.total}\n` +
+                                        `• Successful: ${stats.successful}\n` +
+                                        `• Password Protected: ${stats.passwordProtected}\n` +
+                                        `• Failed: ${stats.failed}\n` +
+                                        `• Text Extracted: ${stats.textExtracted}\n` +
+                                        `• Avg Processing Time: ${stats.averageProcessingTime.toFixed(2)}ms\n\n` +
+                                        `📋 Results:\n` +
+                                        processingResults.map((result, index) => `${index + 1}. ${result.attachment.name}\n` +
+                                            `   📊 Status: ${result.status}\n` +
+                                            `   💾 Size: ${result.metadata.size} bytes\n` +
+                                            `   🔒 Password Protected: ${result.metadata.isPasswordProtected ? 'Yes' : 'No'}\n` +
+                                            `   📝 Text Extracted: ${result.metadata.extractedText ? 'Yes' : 'No'}\n` +
+                                            `   ⏱️ Processing Time: ${result.metadata.processingTime}ms\n` +
+                                            `${result.textContent ? `   📄 Content Preview: ${result.textContent.substring(0, 200)}...\n` : ''}` +
+                                            `${result.errors ? `   ❌ Errors: ${result.errors.join(', ')}\n` : ''}`).join('\n')
+                                }
+                            ]
+                        };
+                    default:
+                        throw new Error(`Unknown AI assistant action: ${aiAction}`);
+                }
+            // ============ PERFORMANCE TESTING TOOL ============
+            case "performance_testing":
+                if (ms365Config.multiUser) {
+                    const userId = args?.userId;
+                    if (!userId) {
+                        throw new Error("User ID is required in multi-user mode");
+                    }
+                    const graphClient = await multiUserMS365Auth.getGraphClientForUser(userId);
+                    ms365Ops.setGraphClient(graphClient);
+                }
+                else {
+                    const graphClient = await enhancedMS365Auth.getGraphClient();
+                    ms365Ops.setGraphClient(graphClient);
+                }
+                const testAction = args?.action;
+                if (!testAction) {
+                    throw new Error("Action is required for performance testing");
+                }
+                switch (testAction) {
+                    case 'run_tests':
+                        // Get recent emails for testing
+                        const testEmailCount = Math.min(args?.testEmailCount || 10, 20);
+                        const recentEmails = await ms365Ops.searchEmails({
+                            maxResults: testEmailCount,
+                            folder: 'inbox'
+                        });
+                        if (recentEmails.messages.length < 5) {
+                            return {
+                                content: [
+                                    {
+                                        type: "text",
+                                        text: `❌ Insufficient emails for testing. Found ${recentEmails.messages.length} emails, need at least 5.\n\n💡 Try sending yourself some test emails or use a different folder.`
+                                    }
+                                ]
+                            };
+                        }
+                        const testMessageIds = recentEmails.messages.map(email => email.id);
+                        const testReport = await batchTestRunner.runAllTests(testMessageIds);
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: `🔬 COMPREHENSIVE PERFORMANCE TEST RESULTS\n\n${testReport}\n\n💡 These tests demonstrate the significant performance improvements achieved with native Microsoft Graph JSON batching!`
+                                }
+                            ]
+                        };
+                    case 'benchmark_bulk_retrieval':
+                        const retrievalTestCount = Math.min(args?.testEmailCount || 10, 20);
+                        const retrievalEmails = await ms365Ops.searchEmails({
+                            maxResults: retrievalTestCount,
+                            folder: args?.folderId || 'inbox'
+                        });
+                        if (retrievalEmails.messages.length < 5) {
+                            throw new Error(`Insufficient emails for testing. Found ${retrievalEmails.messages.length}, need at least 5.`);
+                        }
+                        const retrievalTestIds = retrievalEmails.messages.slice(0, Math.min(10, retrievalEmails.messages.length)).map(e => e.id);
+                        const retrievalResult = await batchTestRunner.testBulkEmailRetrieval(retrievalTestIds);
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: `📧 BULK EMAIL RETRIEVAL BENCHMARK\n\n` +
+                                        `🔍 Tested: ${retrievalTestIds.length} emails${args?.includeAttachments ? ' with attachments' : ''}\n\n` +
+                                        `📊 Results:\n` +
+                                        `• Traditional: ${retrievalResult.traditional.metrics.duration}ms (${retrievalResult.traditional.metrics.httpCalls} HTTP calls)\n` +
+                                        `• Batched: ${retrievalResult.batched.metrics.duration}ms (${retrievalResult.batched.metrics.httpCalls} HTTP calls)\n\n` +
+                                        `🏆 Performance Improvement:\n` +
+                                        `• ${retrievalResult.comparison?.improvement.durationReduction.toFixed(1)}% faster execution\n` +
+                                        `• ${retrievalResult.comparison?.improvement.httpCallReduction.toFixed(1)}% fewer HTTP calls\n` +
+                                        `• ${retrievalResult.comparison?.improvement.efficiencyGain.toFixed(1)}% better efficiency per request`
+                                }
+                            ]
+                        };
+                    case 'benchmark_bulk_operations':
+                        const operationsTestCount = Math.min(args?.testEmailCount || 10, 20);
+                        const operationsEmails = await ms365Ops.searchEmails({
+                            maxResults: operationsTestCount,
+                            folder: args?.folderId || 'inbox'
+                        });
+                        if (operationsEmails.messages.length < 5) {
+                            throw new Error(`Insufficient emails for testing. Found ${operationsEmails.messages.length}, need at least 5.`);
+                        }
+                        const operationsTestIds = operationsEmails.messages.slice(0, Math.min(15, operationsEmails.messages.length)).map(e => e.id);
+                        const operationsResult = await batchTestRunner.testBulkEmailOperations(operationsTestIds);
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: `⚡ BULK EMAIL OPERATIONS BENCHMARK\n\n` +
+                                        `🔍 Tested: ${operationsTestIds.length} ${args?.operationType || 'mark'} operations\n\n` +
+                                        `📊 Results:\n` +
+                                        `• Traditional: ${operationsResult.traditional.metrics.duration}ms (${operationsResult.traditional.metrics.httpCalls} HTTP calls)\n` +
+                                        `• Batched: ${operationsResult.batched.metrics.duration}ms (${operationsResult.batched.metrics.httpCalls} HTTP calls)\n\n` +
+                                        `🏆 Performance Improvement:\n` +
+                                        `• ${operationsResult.comparison?.improvement.durationReduction.toFixed(1)}% faster execution\n` +
+                                        `• ${operationsResult.comparison?.improvement.httpCallReduction.toFixed(1)}% fewer HTTP calls\n` +
+                                        `• ${operationsResult.comparison?.improvement.efficiencyGain.toFixed(1)}% better efficiency per request`
+                                }
+                            ]
+                        };
+                    case 'benchmark_folder_operations':
+                        const folderResult = await batchTestRunner.testFolderWithEmails(args?.folderId || 'inbox', Math.min(args?.testEmailCount || 10, 15));
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: `📁 FOLDER + EMAILS BENCHMARK\n\n` +
+                                        `🔍 Tested: Folder info + ${args?.testEmailCount || 10} emails\n\n` +
+                                        `📊 Results:\n` +
+                                        `• Traditional: ${folderResult.traditional.metrics.duration}ms (${folderResult.traditional.metrics.httpCalls} HTTP calls)\n` +
+                                        `• Batched: ${folderResult.batched.metrics.duration}ms (${folderResult.batched.metrics.httpCalls} HTTP calls)\n\n` +
+                                        `🏆 Performance Improvement:\n` +
+                                        `• ${folderResult.comparison?.improvement.durationReduction.toFixed(1)}% faster execution\n` +
+                                        `• ${folderResult.comparison?.improvement.httpCallReduction.toFixed(1)}% fewer HTTP calls\n` +
+                                        `• ${folderResult.comparison?.improvement.efficiencyGain.toFixed(1)}% better efficiency per request`
+                                }
+                            ]
+                        };
+                    case 'benchmark_mixed_operations':
+                        const mixedTestCount = Math.min(args?.testEmailCount || 12, 20);
+                        const mixedEmails = await ms365Ops.searchEmails({
+                            maxResults: mixedTestCount,
+                            folder: args?.folderId || 'inbox'
+                        });
+                        if (mixedEmails.messages.length < 9) {
+                            throw new Error(`Insufficient emails for mixed operations testing. Found ${mixedEmails.messages.length}, need at least 9.`);
+                        }
+                        const mixedTestIds = mixedEmails.messages.slice(0, Math.min(12, mixedEmails.messages.length)).map(e => e.id);
+                        const mixedResult = await batchTestRunner.testMixedOperations(mixedTestIds);
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: `🔄 MIXED OPERATIONS WORKFLOW BENCHMARK\n\n` +
+                                        `🔍 Tested: ${mixedTestIds.length} mixed operations (mark, move, delete simulation)\n\n` +
+                                        `📊 Results:\n` +
+                                        `• Traditional: ${mixedResult.traditional.metrics.duration}ms (${mixedResult.traditional.metrics.httpCalls} HTTP calls)\n` +
+                                        `• Batched: ${mixedResult.batched.metrics.duration}ms (${mixedResult.batched.metrics.httpCalls} HTTP calls)\n\n` +
+                                        `🏆 Performance Improvement:\n` +
+                                        `• ${mixedResult.comparison?.improvement.durationReduction.toFixed(1)}% faster execution\n` +
+                                        `• ${mixedResult.comparison?.improvement.httpCallReduction.toFixed(1)}% fewer HTTP calls\n` +
+                                        `• ${mixedResult.comparison?.improvement.efficiencyGain.toFixed(1)}% better efficiency per request`
+                                }
+                            ]
+                        };
+                    case 'generate_report':
+                        const performanceReport = performanceMonitor.generateReport();
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: `📊 COMPREHENSIVE PERFORMANCE REPORT\n\n${performanceReport}\n\n💡 This report shows cumulative performance data from all batch operations executed during this session.`
+                                }
+                            ]
+                        };
+                    case 'clear_metrics':
+                        performanceMonitor.clear();
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: `✅ Performance metrics cleared. Ready for new testing session.`
+                                }
+                            ]
+                        };
+                    default:
+                        throw new Error(`Unknown performance testing action: ${testAction}`);
+                }
+            // ============ SEARCH-BATCH PIPELINE TOOL ============
+            case "search_batch_pipeline":
+                if (ms365Config.multiUser) {
+                    const userId = args?.userId;
+                    if (!userId) {
+                        throw new Error("User ID is required in multi-user mode");
+                    }
+                    const graphClient = await multiUserMS365Auth.getGraphClientForUser(userId);
+                    ms365Ops.setGraphClient(graphClient);
+                }
+                else {
+                    const graphClient = await enhancedMS365Auth.getGraphClient();
+                    ms365Ops.setGraphClient(graphClient);
+                }
+                const pipelineAction = args?.action;
+                if (!pipelineAction) {
+                    throw new Error("Action is required for search-batch pipeline");
+                }
+                switch (pipelineAction) {
+                    case 'search_and_retrieve':
+                        const searchCriteria = {
+                            query: args?.query,
+                            from: args?.from,
+                            to: args?.to,
+                            subject: args?.subject,
+                            folder: args?.folder,
+                            after: args?.after,
+                            before: args?.before,
+                            hasAttachment: args?.hasAttachment,
+                            isUnread: args?.isUnread,
+                            importance: args?.importance,
+                            maxResults: args?.maxResults || 50
+                        };
+                        const retrieveResult = await searchBatchPipeline.searchAndRetrieveFull(searchCriteria, args?.includeAttachments || false);
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: `🔄 SEARCH-TO-BATCH PIPELINE: Retrieve Full Details\n\n` +
+                                        `📊 ${retrieveResult.searchSummary}\n\n` +
+                                        `🚀 Performance Improvement:\n` +
+                                        `• Traditional: ${retrieveResult.performance.traditionalCalls} HTTP calls\n` +
+                                        `• Batched: ${retrieveResult.performance.batchedCalls} HTTP calls\n` +
+                                        `• Reduction: ${retrieveResult.performance.callReduction.toFixed(1)}%\n` +
+                                        `• Time: ${retrieveResult.performance.timeEstimate}\n\n` +
+                                        `📧 Retrieved Emails:\n` +
+                                        retrieveResult.emails.map((email, index) => `${index + 1}. ${email.subject}\n` +
+                                            `   👤 From: ${email.from.name} <${email.from.address}>\n` +
+                                            `   📅 ${new Date(email.receivedDateTime).toLocaleString()}\n` +
+                                            `   ${email.hasAttachments ? '📎 Has attachments' : ''}\n`).join('\n')
+                                }
+                            ]
+                        };
+                    case 'search_and_mark_read':
+                    case 'search_and_mark_unread':
+                        const markCriteria = {
+                            query: args?.query,
+                            from: args?.from,
+                            to: args?.to,
+                            subject: args?.subject,
+                            folder: args?.folder,
+                            after: args?.after,
+                            before: args?.before,
+                            hasAttachment: args?.hasAttachment,
+                            isUnread: args?.isUnread,
+                            importance: args?.importance
+                        };
+                        const markAction = pipelineAction === 'search_and_mark_read' ? 'mark_read' : 'mark_unread';
+                        const markResult = await searchBatchPipeline.executeSearchBatchPipeline({
+                            searchCriteria: markCriteria,
+                            batchAction: markAction,
+                            maxResults: args?.maxResults || 50
+                        });
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: `🔄 SEARCH-TO-BATCH PIPELINE: Mark as ${markAction === 'mark_read' ? 'Read' : 'Unread'}\n\n` +
+                                        `📊 Search Results: ${markResult.searchResults.foundEmails} emails found (${markResult.searchResults.searchTime}ms)\n` +
+                                        `📧 Batch Results: ${markResult.batchResults.successCount} marked successfully, ${markResult.batchResults.errorCount} errors (${markResult.batchResults.batchTime}ms)\n\n` +
+                                        `🚀 Performance Improvement:\n` +
+                                        `• Traditional: ${markResult.performanceImprovement.traditionalCalls} HTTP calls\n` +
+                                        `• Batched: ${markResult.performanceImprovement.batchedCalls} HTTP calls\n` +
+                                        `• Reduction: ${markResult.performanceImprovement.callReduction.toFixed(1)}%\n` +
+                                        `• Time: ${markResult.performanceImprovement.timeEstimate}\n\n` +
+                                        `✅ Total Time: ${markResult.totalTime}ms`
+                                }
+                            ]
+                        };
+                    case 'search_and_move':
+                        if (!args?.destinationFolderId) {
+                            throw new Error("destinationFolderId is required for search_and_move action");
+                        }
+                        const moveCriteria = {
+                            query: args?.query,
+                            from: args?.from,
+                            to: args?.to,
+                            subject: args?.subject,
+                            folder: args?.folder,
+                            after: args?.after,
+                            before: args?.before,
+                            hasAttachment: args?.hasAttachment,
+                            isUnread: args?.isUnread,
+                            importance: args?.importance
+                        };
+                        const moveResult = await searchBatchPipeline.executeSearchBatchPipeline({
+                            searchCriteria: moveCriteria,
+                            batchAction: 'move',
+                            batchParams: { destinationFolderId: args.destinationFolderId },
+                            maxResults: args?.maxResults || 50
+                        });
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: `🔄 SEARCH-TO-BATCH PIPELINE: Move to Folder\n\n` +
+                                        `📊 Search Results: ${moveResult.searchResults.foundEmails} emails found (${moveResult.searchResults.searchTime}ms)\n` +
+                                        `📧 Batch Results: ${moveResult.batchResults.successCount} moved successfully, ${moveResult.batchResults.errorCount} errors (${moveResult.batchResults.batchTime}ms)\n` +
+                                        `📁 Destination: ${args.destinationFolderId}\n\n` +
+                                        `🚀 Performance Improvement:\n` +
+                                        `• Traditional: ${moveResult.performanceImprovement.traditionalCalls} HTTP calls\n` +
+                                        `• Batched: ${moveResult.performanceImprovement.batchedCalls} HTTP calls\n` +
+                                        `• Reduction: ${moveResult.performanceImprovement.callReduction.toFixed(1)}%\n` +
+                                        `• Time: ${moveResult.performanceImprovement.timeEstimate}\n\n` +
+                                        `✅ Total Time: ${moveResult.totalTime}ms`
+                                }
+                            ]
+                        };
+                    case 'search_and_delete':
+                        const deleteCriteria = {
+                            query: args?.query,
+                            from: args?.from,
+                            to: args?.to,
+                            subject: args?.subject,
+                            folder: args?.folder,
+                            after: args?.after,
+                            before: args?.before,
+                            hasAttachment: args?.hasAttachment,
+                            isUnread: args?.isUnread,
+                            importance: args?.importance
+                        };
+                        const deleteResult = await searchBatchPipeline.executeSearchBatchPipeline({
+                            searchCriteria: deleteCriteria,
+                            batchAction: 'delete',
+                            maxResults: args?.maxResults || 50
+                        });
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: `🔄 SEARCH-TO-BATCH PIPELINE: Delete Emails\n\n` +
+                                        `📊 Search Results: ${deleteResult.searchResults.foundEmails} emails found (${deleteResult.searchResults.searchTime}ms)\n` +
+                                        `📧 Batch Results: ${deleteResult.batchResults.successCount} deleted successfully, ${deleteResult.batchResults.errorCount} errors (${deleteResult.batchResults.batchTime}ms)\n\n` +
+                                        `🚀 Performance Improvement:\n` +
+                                        `• Traditional: ${deleteResult.performanceImprovement.traditionalCalls} HTTP calls\n` +
+                                        `• Batched: ${deleteResult.performanceImprovement.batchedCalls} HTTP calls\n` +
+                                        `• Reduction: ${deleteResult.performanceImprovement.callReduction.toFixed(1)}%\n` +
+                                        `• Time: ${deleteResult.performanceImprovement.timeEstimate}\n\n` +
+                                        `✅ Total Time: ${deleteResult.totalTime}ms`
+                                }
+                            ]
+                        };
+                    case 'quick_workflows':
+                        const workflowType = args?.workflowType;
+                        if (!workflowType) {
+                            throw new Error("workflowType is required for quick_workflows action");
+                        }
+                        const workflows = await searchBatchPipeline.quickWorkflows();
+                        let workflowResult;
+                        switch (workflowType) {
+                            case 'mark_sender_read':
+                                if (!args?.senderEmail) {
+                                    throw new Error("senderEmail is required for mark_sender_read workflow");
+                                }
+                                workflowResult = await workflows.markSenderEmailsRead(args.senderEmail);
+                                break;
+                            case 'move_by_subject':
+                                if (!args?.subjectText || !args?.destinationFolderId) {
+                                    throw new Error("subjectText and destinationFolderId are required for move_by_subject workflow");
+                                }
+                                workflowResult = await workflows.moveEmailsBySubject(args.subjectText, args.destinationFolderId);
+                                break;
+                            case 'delete_old':
+                                if (!args?.beforeDate) {
+                                    throw new Error("beforeDate is required for delete_old workflow");
+                                }
+                                workflowResult = await workflows.deleteOldEmails(args.beforeDate);
+                                break;
+                            case 'get_attachments':
+                                if (!args?.senderEmail) {
+                                    throw new Error("senderEmail is required for get_attachments workflow");
+                                }
+                                workflowResult = await workflows.getEmailsWithAttachments(args.senderEmail);
+                                break;
+                            default:
+                                throw new Error(`Unknown workflow type: ${workflowType}`);
+                        }
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: `🔄 QUICK WORKFLOW: ${workflowType}\n\n` +
+                                        `📊 Search Results: ${workflowResult.searchResults?.foundEmails || 'N/A'} emails found\n` +
+                                        `📧 Batch Results: ${workflowResult.batchResults?.successCount || 'N/A'} processed successfully\n\n` +
+                                        `🚀 Performance Improvement:\n` +
+                                        `• Traditional: ${workflowResult.performanceImprovement?.traditionalCalls || 'N/A'} HTTP calls\n` +
+                                        `• Batched: ${workflowResult.performanceImprovement?.batchedCalls || 'N/A'} HTTP calls\n` +
+                                        `• Reduction: ${workflowResult.performanceImprovement?.callReduction?.toFixed(1) || 'N/A'}%\n` +
+                                        `• Time: ${workflowResult.performanceImprovement?.timeEstimate || 'N/A'}\n\n` +
+                                        `✅ Workflow completed in ${workflowResult.totalTime || 'N/A'}ms`
+                                }
+                            ]
+                        };
+                    default:
+                        throw new Error(`Unknown pipeline action: ${pipelineAction}`);
+                }
             default:
                 throw new Error(`Unknown tool: ${name}`);
         }