@realtimex/email-automator 2.6.4 → 2.7.0

package/api/src/services/processor.ts

@@ -4,7 +4,7 @@ import { createLogger } from '../utils/logger.js';
 import { config } from '../config/index.js';
 import { getGmailService, GmailMessage } from './gmail.js';
 import { getMicrosoftService, OutlookMessage } from './microsoft.js';
-import { getIntelligenceService, EmailAnalysis } from './intelligence.js';
+import { getIntelligenceService, EmailAnalysis, ContextAwareAnalysis, RuleContext } from './intelligence.js';
 import { getStorageService } from './storage.js';
 import { EmailAccount, Email, Rule, ProcessingLog } from './supabase.js';
 import { EventLogger } from './eventLogger.js';
@@ -55,8 +55,8 @@ export class EmailProcessorService {
                 throw new Error('Account not found or access denied');
             }
 
-            logger.info('Retrieved account settings', { 
-                accountId: account.id, 
+            logger.info('Retrieved account settings', {
+                accountId: account.id,
                 sync_start_date: account.sync_start_date,
                 last_sync_checkpoint: account.last_sync_checkpoint
             });
@@ -104,7 +104,7 @@ export class EmailProcessorService {
             await this.runRetentionRules(refreshedAccount, rules || [], settings, result, eventLogger);
 
             // Trigger background worker (async) to process the queue
-            this.processQueue(userId, settings).catch(err => 
+            this.processQueue(userId, settings).catch(err =>
                 logger.error('Background worker failed', err)
             );
 
@@ -160,7 +160,7 @@ export class EmailProcessorService {
             if (errMsg.includes('Account not found') || errMsg.includes('access denied')) {
                 throw error;
             }
-            
+
             // Otherwise, increment error count and return partial results
             result.errors++;
         }
@@ -199,7 +199,7 @@ export class EmailProcessorService {
         const windowSizeMs = 7 * 24 * 60 * 60 * 1000;
         const nowMs = Date.now();
         const tomorrowMs = nowMs + (24 * 60 * 60 * 1000);
-        
+
         let currentStartMs = effectiveStartMs;
         let messages: GmailMessage[] = [];
         let hasMore = false;
@@ -231,7 +231,7 @@ export class EmailProcessorService {
             logger.info('No emails in 7-day window, skipping forward', { start: new Date(currentStartMs).toISOString() });
             currentStartMs = effectiveEndMs;
             attempts++;
-            
+
             if (eventLogger && attempts % 3 === 0) {
                 await eventLogger.info('Sync', `Scanning history... reached ${new Date(currentStartMs).toLocaleDateString()}`);
             }
@@ -262,17 +262,17 @@ export class EmailProcessorService {
 
         // Update checkpoint once at the end of the batch if we made progress
         if (maxInternalDate > effectiveStartMs) {
-            logger.info('Updating Gmail checkpoint', { 
-                accountId: account.id, 
+            logger.info('Updating Gmail checkpoint', {
+                accountId: account.id,
                 oldCheckpoint: account.last_sync_checkpoint,
-                newCheckpoint: maxInternalDate.toString() 
+                newCheckpoint: maxInternalDate.toString()
             });
-            
+
             const { error: updateError } = await this.supabase
                 .from('email_accounts')
                 .update({ last_sync_checkpoint: maxInternalDate.toString() })
                 .eq('id', account.id);
-            
+
             if (updateError) {
                 logger.error('Failed to update Gmail checkpoint', updateError);
             }
@@ -346,12 +346,12 @@ export class EmailProcessorService {
 
         // Update checkpoint once at the end of the batch if we made progress
         if (latestCheckpoint && latestCheckpoint !== effectiveStartIso) {
-            logger.info('Updating Outlook checkpoint', { 
-                accountId: account.id, 
+            logger.info('Updating Outlook checkpoint', {
+                accountId: account.id,
                 oldCheckpoint: account.last_sync_checkpoint,
-                newCheckpoint: latestCheckpoint 
+                newCheckpoint: latestCheckpoint
             });
-            
+
             const { error: updateError } = await this.supabase
                 .from('email_accounts')
                 .update({ last_sync_checkpoint: latestCheckpoint })
@@ -387,11 +387,11 @@ export class EmailProcessorService {
         if (existing) {
             logger.debug('Message already processed', { messageId: message.id });
             if (eventLogger) await eventLogger.info('Skipped', `Already processed ID: ${message.id}`);
-            
+
             // Still need to return the date for checkpointing even if skipped
-            const rawMime = 'raw' in message 
-                ? (account.provider === 'gmail' 
-                    ? Buffer.from(message.raw, 'base64').toString('utf-8') 
+            const rawMime = 'raw' in message
+                ? (account.provider === 'gmail'
+                    ? Buffer.from(message.raw, 'base64').toString('utf-8')
                     : message.raw)
                 : '';
             if (rawMime) {
@@ -400,11 +400,11 @@ export class EmailProcessorService {
             }
             return;
         }
-        
+
         // Extract raw content string (Gmail is base64url, Outlook is raw text from $value)
-        const rawMime = 'raw' in message 
-            ? (account.provider === 'gmail' 
-                ? Buffer.from(message.raw, 'base64').toString('utf-8') 
+        const rawMime = 'raw' in message
+            ? (account.provider === 'gmail'
+                ? Buffer.from(message.raw, 'base64').toString('utf-8')
                 : message.raw)
             : '';
 
@@ -462,7 +462,7 @@ export class EmailProcessorService {
         if (eventLogger) await eventLogger.info('Ingested', `Successfully ingested email: ${subject}`, { filePath }, savedEmail.id);
 
         result.processed++;
-        
+
         return { date };
     }
 
@@ -522,7 +522,7 @@ export class EmailProcessorService {
                 .select('processing_status')
                 .eq('id', email.id)
                 .single();
-            
+
             if (current?.processing_status !== 'pending') {
                 if (log) await this.supabase.from('processing_logs').delete().eq('id', log.id);
                 return;
@@ -539,7 +539,7 @@ export class EmailProcessorService {
             if (!email.file_path) throw new Error('No file path found for email');
             const rawMime = await this.storageService.readEmail(email.file_path);
             const parsed = await simpleParser(rawMime);
-            
+
             // Extract clean content (prioritize text)
             const cleanContent = parsed.text || parsed.textAsHtml || '';
 
@@ -551,7 +551,68 @@ export class EmailProcessorService {
                 mailer: parsed.headers.get('x-mailer')?.toString()
             };
 
-            // 3. Analyze with AI
+            // 3. Fetch account for action execution
+            const { data: account } = await this.supabase
+                .from('email_accounts')
+                .select('*')
+                .eq('id', email.account_id)
+                .single();
+
+            // 4. Fetch pre-compiled rule context (fast path - no loop/formatting)
+            // Falls back to building context if not cached
+            let compiledContext: string | null = settings?.compiled_rule_context || null;
+
+            // Fetch rules for action execution (need attachments, instructions)
+            const { data: rules } = await this.supabase
+                .from('rules')
+                .select('*')
+                .eq('user_id', userId)
+                .eq('is_enabled', true)
+                .order('priority', { ascending: false });
+
+            // Fallback: build context if not pre-compiled
+            if (!compiledContext && rules && rules.length > 0) {
+                compiledContext = rules.map((r, i) => {
+                    // Build human-readable condition text
+                    let conditionText = '';
+                    if (r.condition) {
+                        const cond = r.condition as any;
+                        if (cond.field) {
+                            conditionText = `When ${cond.field}`;
+                            if (cond.operator === 'equals') {
+                                conditionText += ` equals "${cond.value}"`;
+                            } else if (cond.operator === 'contains') {
+                                conditionText += ` contains "${cond.value}"`;
+                            } else if (cond.operator === 'domain_equals') {
+                                conditionText += ` domain equals "${cond.value}"`;
+                            } else {
+                                conditionText += ` ${cond.operator} "${cond.value}"`;
+                            }
+                        }
+                        if (cond.is_useless === true) {
+                            conditionText += (conditionText ? ' AND ' : 'When ') + 'email is useless/low-value';
+                        }
+                        if (cond.ai_priority) {
+                            conditionText += (conditionText ? ' AND ' : 'When ') + `AI priority is "${cond.ai_priority}"`;
+                        }
+                        // Extract older_than_days from condition JSONB
+                        if (cond.older_than_days) {
+                            conditionText += (conditionText ? ' AND ' : 'When ') + `email is older than ${cond.older_than_days} days`;
+                        }
+                    }
+
+                    return `Rule ${i + 1} [ID: ${r.id}]\n` +
+                        `  Name: ${r.name}\n` +
+                        (r.description ? `  Description: ${r.description}\n` : '') +
+                        (r.intent ? `  Intent: ${r.intent}\n` : '') +
+                        (conditionText ? `  Condition: ${conditionText}\n` : '') +
+                        `  Actions: ${r.actions?.join(', ') || r.action || 'none'}\n` +
+                        (r.instructions ? `  Draft Instructions: ${r.instructions}\n` : '') +
+                        '\n';
+                }).join('');
+            }
+
+            // 5. Context-Aware Analysis: AI evaluates email against user's rules
             const intelligenceService = getIntelligenceService(
                 settings?.llm_model || settings?.llm_base_url || settings?.llm_api_key
                     ? {
@@ -562,63 +623,86 @@ export class EmailProcessorService {
                     : undefined
             );
 
-            const analysis = await intelligenceService.analyzeEmail(cleanContent, {
-                subject: email.subject || '',
-                sender: email.sender || '',
-                date: email.date || '',
-                metadata,
-                userPreferences: {
-                    autoTrashSpam: settings?.auto_trash_spam,
-                    smartDrafts: settings?.smart_drafts,
+            const analysis = await intelligenceService.analyzeEmailWithRules(
+                cleanContent,
+                {
+                    subject: email.subject || '',
+                    sender: email.sender || '',
+                    date: email.date || '',
+                    metadata,
+                    userPreferences: {
+                        autoTrashSpam: settings?.auto_trash_spam,
+                        smartDrafts: settings?.smart_drafts,
+                    },
                 },
-            }, eventLogger || undefined, email.id);
+                compiledContext || '',  // Pre-compiled context (fast path)
+                eventLogger || undefined,
+                email.id
+            );
 
             if (!analysis) {
                 throw new Error('AI analysis returned no result');
             }
 
-            // 4. Update the email record with results
+            // 6. Update the email record with context-aware results
             await this.supabase
                 .from('emails')
                 .update({
                     category: analysis.category,
-                    is_useless: analysis.is_useless,
                     ai_analysis: analysis as any,
-                    suggested_actions: analysis.suggested_actions || [],
-                    suggested_action: analysis.suggested_actions?.[0] || 'none',
+                    suggested_actions: analysis.actions_to_execute || [],
+                    suggested_action: analysis.actions_to_execute?.[0] || 'none',
+                    matched_rule_id: analysis.matched_rule.rule_id,
+                    matched_rule_confidence: analysis.matched_rule.confidence,
                     processing_status: 'completed'
                 })
                 .eq('id', email.id);
 
-            // 5. Execute automation rules
-            // Fetch account and rules needed for execution
-            const { data: account } = await this.supabase
-                .from('email_accounts')
-                .select('*')
-                .eq('id', email.account_id)
-                .single();
+            // 7. Execute actions if rule matched with sufficient confidence
+            if (account && analysis.matched_rule.rule_id && analysis.matched_rule.confidence >= 0.7) {
+                const matchedRule = rules?.find(r => r.id === analysis.matched_rule.rule_id);
 
-            const { data: rules } = await this.supabase
-                .from('rules')
-                .select('*')
-                .eq('user_id', userId)
-                .eq('is_enabled', true);
+                if (eventLogger) {
+                    await eventLogger.info('Rule Matched',
+                        `"${analysis.matched_rule.rule_name}" matched with ${(analysis.matched_rule.confidence * 100).toFixed(0)}% confidence`,
+                        { reasoning: analysis.matched_rule.reasoning },
+                        email.id
+                    );
+                }
 
-            if (account && rules) {
-                const tempResult = { processed: 0, deleted: 0, drafted: 0, errors: 0 };
-                // Ensure email object for rules has the analysis fields merged in
-                const emailForRules = { ...email, ...analysis };
-                await this.executeRules(account, emailForRules as any, analysis, rules, settings, tempResult, eventLogger);
+                // Execute each action from the AI's decision
+                for (const action of analysis.actions_to_execute) {
+                    if (action === 'none') continue;
+
+                    // Use AI-generated draft content if available
+                    const draftContent = action === 'draft' ? analysis.draft_content : undefined;
+
+                    await this.executeAction(
+                        account,
+                        email,
+                        action as any,
+                        draftContent,
+                        eventLogger,
+                        `Rule: ${matchedRule?.name || analysis.matched_rule.rule_name}`,
+                        matchedRule?.attachments
+                    );
+                }
+            } else if (eventLogger && rules && rules.length > 0) {
+                await eventLogger.info('No Match',
+                    analysis.matched_rule.reasoning,
+                    { confidence: analysis.matched_rule.confidence },
+                    email.id
+                );
             }
 
             // Mark log as success
             if (log) {
                 await this.supabase
                     .from('processing_logs')
-                    .update({ 
-                        status: 'success', 
+                    .update({
+                        status: 'success',
                         completed_at: new Date().toISOString(),
-                        emails_processed: 1 
+                        emails_processed: 1
                     })
                     .eq('id', log.id);
             }
@@ -626,13 +710,13 @@ export class EmailProcessorService {
         } catch (error) {
             logger.error('Failed to process pending email', error, { emailId: email.id });
             if (eventLogger) await eventLogger.error('Processing Failed', error, email.id);
-            
+
             // Mark log as failed
             if (log) {
                 await this.supabase
                     .from('processing_logs')
-                    .update({ 
-                        status: 'failed', 
+                    .update({
+                        status: 'failed',
                         completed_at: new Date().toISOString(),
                         error_message: error instanceof Error ? error.message : String(error)
                     })
@@ -641,7 +725,7 @@ export class EmailProcessorService {
 
             await this.supabase
                 .from('emails')
-                .update({ 
+                .update({
                     processing_status: 'failed',
                     processing_error: error instanceof Error ? error.message : String(error),
                     retry_count: (email.retry_count || 0) + 1
@@ -711,10 +795,10 @@ export class EmailProcessorService {
 
     private matchesCondition(email: Partial<Email>, analysis: EmailAnalysis, condition: Record<string, unknown>): boolean {
         if (!analysis) return false;
-        
+
         for (const [key, value] of Object.entries(condition)) {
             const val = value as string;
-            
+
             switch (key) {
                 case 'sender_email':
                     if (email.sender?.toLowerCase() !== val.toLowerCase()) return false;
@@ -755,7 +839,7 @@ export class EmailProcessorService {
                     // Handle array membership check (e.g. if condition expects "reply" to be in actions)
                     const requiredActions = Array.isArray(value) ? value : [value];
                     const actualActions = analysis.suggested_actions || [];
-                    const hasAllActions = requiredActions.every(req => 
+                    const hasAllActions = requiredActions.every(req =>
                         actualActions.includes(req as any)
                     );
                     if (!hasAllActions) return false;
@@ -881,7 +965,7 @@ export class EmailProcessorService {
                 .eq('id', email.id);
 
             logger.debug('Action executed', { emailId: email.id, action });
-            
+
             if (eventLogger) {
                 await eventLogger.action('Acted', email.id, action, reason);
             }

package/api/src/services/supabase.ts

@@ -115,10 +115,13 @@ export interface Rule {
     id: string;
     user_id: string;
     name: string;
-    condition: Record<string, unknown>;
+    description?: string;  // Semantic context for AI matching
+    intent?: string;       // The intent behind the rule (e.g., "Politely decline sales pitches")
+    priority?: number;     // Higher = evaluated first by AI
+    condition: Record<string, unknown>; // Legacy - kept for backwards compatibility
     action?: 'delete' | 'archive' | 'draft' | 'star' | 'read'; // Legacy single action
     actions?: ('delete' | 'archive' | 'draft' | 'star' | 'read')[]; // New multi-action array
-    instructions?: string;
+    instructions?: string; // Draft generation instructions
     attachments?: any[];
     is_enabled: boolean;
     created_at: string;

package/api/src/utils/contentCleaner.ts

@@ -1,96 +1,111 @@
 export class ContentCleaner {
     /**
      * Cleans email body by removing noise, quoted replies, and footers.
-     * Ported from Python ContentCleaner.
+     * optimized for LLM processing.
      */
     static cleanEmailBody(text: string): string {
         if (!text) return "";
         const originalText = text;
 
-        // 0. Lightweight HTML -> Markdown Conversion
-        
-        // Structure: <br>, <p> -> Newlines
-        text = text.replace(/<br\s*\/?>/gi, '\n');
-        text = text.replace(/<\/p>/gi, '\n\n');
-        text = text.replace(/<p.*?>/gi, ''); // Open p tags just gone
-        
-        // Structure: Headers <h1>-<h6> -> # Title
-        text = text.replace(/<h[1-6].*?>(.*?)<\/h[1-6]>/gsi, (match, p1) => `\n# ${p1}\n`);
-        
-        // Structure: Lists <li> -> - Item
-        text = text.replace(/<li.*?>(.*?)<\/li>/gsi, (match, p1) => `\n- ${p1}`);
-        text = text.replace(/<ul.*?>/gi, '');
-        text = text.replace(/<\/ul>/gi, '\n');
-        
-        // Links: <a href=\"...\">text</a> -> [text](href)
-        text = text.replace(/<a\s+(?:[^>]*?\s+)?href=\"([^\"]*)\"[^>]*>(.*?)<\/a>/gsi, (match, href, content) => `[${content}](${href})`);
-        
-        // Images: <img src=\"...\" alt=\"...\"> -> ![alt](src)
-        text = text.replace(/<img\s+(?:[^>]*?\s+)?src=\"([^\"]*)\"(?:[^>]*?\s+)?alt=\"([^\"]*)\"[^>]*>/gsi, (match, src, alt) => `![${alt}](${src})`);
+        // 1. Detect if content is actually HTML
+        const isHtml = /<[a-z][\s\S]*>/i.test(text);
 
-        // Style/Script removal (strictly remove content)
-        text = text.replace(/<script.*?>.*?<\/script>/gsi, '');
-        text = text.replace(/<style.*?>.*?<\/style>/gsi, '');
-        
-        // Final Strip of remaining tags
-        text = text.replace(/<[^>]+>/g, ' ');
-        
-        // Entity decoding (Basic)
-        text = text.replace(/&nbsp;/gi, ' ');
-        text = text.replace(/&amp;/gi, '&');
-        text = text.replace(/&lt;/gi, '<');
-        text = text.replace(/&gt;/gi, '>');
-        text = text.replace(/&quot;/gi, '"');
-        text = text.replace(/&#39;/gi, "'");
+        if (isHtml) {
+            // Lightweight HTML -> Markdown Conversion
+            // Structure: <br>, <p> -> Newlines
+            text = text.replace(/<br\s*\/?>/gi, '\n');
+            text = text.replace(/<\/p>/gi, '\n\n');
+            text = text.replace(/<p.*?>/gi, ''); 
+            
+            // Structure: Headers <h1>-<h6> -> # Title
+            text = text.replace(/<h[1-6].*?>(.*?)<\/h[1-6]>/gsi, (match, p1) => `\n# ${p1}\n`);
+            
+            // Structure: Lists <li> -> - Item
+            text = text.replace(/<li.*?>(.*?)<\/li>/gsi, (match, p1) => `\n- ${p1}`);
+            text = text.replace(/<ul.*?>/gi, '');
+            text = text.replace(/<\/ul>/gi, '\n');
+            
+            // Links: <a href=\"...\">text</a> -> [text](href)
+            text = text.replace(/<a\s+(?:[^>]*?\s+)?href=\"([^\"]*)\"[^>]*>(.*?)<\/a>/gsi, (match, href, content) => `[${content}](${href})`);
+            
+            // Images: <img src=\"...\" alt=\"...\"> -> ![alt](src)
+            text = text.replace(/<img\s+(?:[^>]*?\s+)?src=\"([^\"]*)\"(?:[^>]*?\s+)?alt=\"([^\"]*)\"[^>]*>/gsi, (match, src, alt) => `![${alt}](${src})`);
+
+            // Style/Script removal (strictly remove content)
+            text = text.replace(/<script.*?>.*?<\/script>/gsi, '');
+            text = text.replace(/<style.*?>.*?<\/style>/gsi, '');
+            
+            // Final Strip of remaining tags
+            text = text.replace(/<[^>]+>/g, ' ');
+            
+            // Entity decoding (Basic)
+            text = text.replace(/&nbsp;/gi, ' ');
+            text = text.replace(/&amp;/gi, '&');
+            text = text.replace(/&lt;/gi, '<');
+            text = text.replace(/&gt;/gi, '>');
+            text = text.replace(/&quot;/gi, '"');
+            text = text.replace(/&#39;/gi, "'");
+        }
 
         const lines = text.split('\n');
         const cleanedLines: string[] = [];
         
-        // Heuristics for reply headers
-        const replyHeaderPatterns = [
+        // Patterns that usually mark the START of a reply chain or a generic footer
+        const truncationPatterns = [
             /^On .* wrote:$/i,
-            /^From: .*$/i,
-            /^Sent: .*$/i,
-            /^To: .*$/i,
-            /^Subject: .*$/i
+            /^From: .* <.*>$/i,
+            /^-----Original Message-----$/i,
+            /^________________________________$/i,
+            /^Sent from my iPhone$/i,
+            /^Sent from my Android$/i,
+            /^Get Outlook for/i,
+            /^--$/ // Standard signature separator
         ];
 
-        // Heuristics for footers
-        const footerPatterns = [
-            /unsubscribe/i,
+        // Patterns for lines that should be stripped but NOT truncate the whole email
+        const noisePatterns = [
+            /view in browser/i,
+            /click here to view/i,
+            /legal notice/i,
+            /all rights reserved/i,
             /privacy policy/i,
             /terms of service/i,
-            /view in browser/i,
-            /copyright \d{4}/i
+            /unsubscribe/i
         ];
 
         for (let line of lines) {
             let lineStripped = line.trim();
+            if (!lineStripped) {
+                cleanedLines.push("");
+                continue;
+            }
             
             // 2. Quoted text removal (lines starting with >)
             if (lineStripped.startsWith('>')) {
                 continue;
             }
                 
-            // 3. Check for specific reply separators
-            // If we hit a reply header, we truncate the rest
-            if (/^On .* wrote:$/i.test(lineStripped)) {
-                break;
+            // 3. Truncation check: If we hit a reply header, we stop entirely
+            let shouldTruncate = false;
+            for (const pattern of truncationPatterns) {
+                if (pattern.test(lineStripped)) {
+                    shouldTruncate = true;
+                    break;
+                }
             }
+            if (shouldTruncate) break;
 
-            // 4. Footer removal (only on very short lines to avoid stripping body content)
-            if (lineStripped.length < 60) {
-                let isFooter = false;
-                for (const pattern of footerPatterns) {
+            // 4. Noise check: Strip boilerplate lines
+            let isNoise = false;
+            if (lineStripped.length < 100) {
+                for (const pattern of noisePatterns) {
                     if (pattern.test(lineStripped)) {
-                        isFooter = true;
+                        isNoise = true;
                         break;
                     }
                 }
-                if (isFooter) {
-                    continue;
-                }
             }
+            if (isNoise) continue;
 
             cleanedLines.push(line);
         }
@@ -98,21 +113,20 @@ export class ContentCleaner {
         // Reassemble
         text = cleanedLines.join('\n');
         
-        // Safety Fallback: If cleaning stripped everything, return original (truncated)
-        if (!text.trim() || text.length < 10) {
-            text = originalText.substring(0, 3000);
-        }
-
-        // Collapse multiple newlines
+        // Collapse whitespace
         text = text.replace(/\n{3,}/g, '\n\n');
+        text = text.replace(/[ \t]{2,}/g, ' ');
 
+        // Safety Fallback: If cleaning stripped too much, return original text truncated
+        if (text.trim().length < 20 && originalText.trim().length > 20) {
+            return originalText.substring(0, 3000).trim();
+        }
+        
         // Sanitize LLM Special Tokens
         text = text.replace(/<\|/g, '< |'); 
         text = text.replace(/\|>/g, '| >');
         text = text.replace(/\[INST\]/gi, '[ INST ]');
         text = text.replace(/\[\/INST\]/gi, '[ /INST ]');
-        text = text.replace(/<s>/gi, '&lt;s&gt;');
-        text = text.replace(/<\/s>/gi, '&lt;/s&gt;');
         
         return text.trim();
     }

package/dist/api/src/middleware/validation.js

@@ -82,8 +82,12 @@ export const schemas = {
         accessToken: z.string().optional(),
     }),
     // Rule schemas - supports both single action (legacy) and actions array
+    // Now includes description and intent for context-aware AI matching
     createRule: z.object({
         name: z.string().min(1).max(100),
+        description: z.string().max(500).optional(),
+        intent: z.string().max(200).optional(),
+        priority: z.number().int().min(0).max(100).optional(),
         condition: z.record(z.unknown()),
         action: z.enum(['delete', 'archive', 'draft', 'star', 'read']).optional(),
         actions: z.array(z.enum(['delete', 'archive', 'draft', 'star', 'read'])).optional(),
@@ -94,6 +98,9 @@ export const schemas = {
     }),
     updateRule: z.object({
         name: z.string().min(1).max(100).optional(),
+        description: z.string().max(500).optional(),
+        intent: z.string().max(200).optional(),
+        priority: z.number().int().min(0).max(100).optional(),
         condition: z.record(z.unknown()).optional(),
         action: z.enum(['delete', 'archive', 'draft', 'star', 'read']).optional(),
         actions: z.array(z.enum(['delete', 'archive', 'draft', 'star', 'read'])).optional(),