@xuda.io/ai_module 1.1.4680 → 1.1.4682

package/index.mjs

@@ -7777,7 +7777,7 @@ Category:`;
     const prompt_category_ret = await submit_chat_gpt_prompt({
       uid,
       prompt: prompt,
-      model: 'gpt-4o', // Using GPT-4o for better understanding of AI prompts
+      model: 'gpt-5-nano',
       response_format: z.object({
         prompt_category: z.enum(ai_prompt_categories),
         confidence_score: z.number().min(0).max(100),
@@ -8502,7 +8502,7 @@ Category:`;
     const note_category_ret = await submit_chat_gpt_prompt({
       uid,
       prompt: prompt,
-      model: 'gpt-4o-mini',
+      model: 'gpt-5-nano',
       response_format: z.object({
         note_category: z.enum(note_categories),
         confidence_score: z.number().min(0).max(100),
@@ -9637,7 +9637,7 @@ export const get_person_info = async function (uid, name, email, account_profile
   const person_info_ret = await submit_chat_gpt_prompt({
     uid,
     prompt: context_prompt,
-    model: 'gpt-4o-mini',
+    model: 'gpt-5-nano',
     response_format: z.object({
       // Basic Information
       person_full_name: z.string().describe("Person's full name"),
@@ -10359,3 +10359,793 @@ PROVIDE DETAILED ANALYSIS WITH CONFIDENCE LEVELS.`,
     return getDefaultEmailAnalysis(name, email, email_context, error.message);
   }
 };
+
+export const detect_email_type = async function (uid, name, email, account_profile_info, email_body = '', email_subject = '') {
+  // ========== HELPER FUNCTIONS ==========
+
+  async function hashString(str) {
+    const encoder = new TextEncoder();
+    const data = encoder.encode(str);
+    const hashBuffer = await crypto.subtle.digest('SHA-256', data);
+    const hashArray = Array.from(new Uint8Array(hashBuffer));
+    return hashArray
+      .map((b) => b.toString(16).padStart(2, '0'))
+      .join('')
+      .substring(0, 16);
+  }
+
+  function enhanceEmailDetection(data, name, email, emailBody, emailSubject) {
+    // Run additional local analysis
+    const localAnalysis = analyzeEmailLocally(emailBody, emailSubject, email, name);
+
+    // Combine AI analysis with local analysis
+    const combinedData = {
+      ...data,
+      // Override with local analysis if confidence is high
+      spam_confidence: Math.max(data.spam_confidence, localAnalysis.spamScore),
+      phishing_risk: localAnalysis.phishingScore > 70 ? 'high' : data.phishing_risk,
+
+      // Add local analysis results
+      local_analysis: localAnalysis,
+
+      // Enhance sender analysis
+      sender_analysis: analyzeSender(email, name, emailBody),
+
+      // Content statistics
+      content_stats: {
+        word_count: (emailBody.match(/\S+/g) || []).length,
+        sentence_count: (emailBody.match(/[.!?]+/g) || []).length,
+        link_count: (emailBody.match(/https?:\/\/[^\s]+/g) || []).length,
+        uppercase_ratio: calculateUppercaseRatio(emailBody),
+        exclamation_count: (emailBody.match(/!/g) || []).length,
+        dollar_sign_count: (emailBody.match(/\$/g) || []).length,
+        phone_patterns: (emailBody.match(/\b\d{3}[-.]?\d{3}[-.]?\d{4}\b/g) || []).length,
+      },
+
+      // Behavioral patterns
+      behavioral_patterns: detectBehavioralPatterns(emailBody, emailSubject),
+
+      // Domain reputation
+      domain_reputation: assessDomainReputation(email),
+
+      // Add comprehensive risk assessment
+      comprehensive_risk_score: calculateComprehensiveRisk(data, localAnalysis),
+
+      // Filter rules that matched
+      matched_filters: detectMatchedFilters(emailBody, emailSubject, email, name),
+
+      // Timeline analysis
+      temporal_analysis: {
+        is_time_sensitive: detectTimeSensitivity(emailBody),
+        has_expiry: detectExpiryDate(emailBody),
+        is_follow_up: detectFollowUpPattern(emailBody, emailSubject),
+      },
+
+      // Relationship context
+      relationship_context: analyzeRelationshipContext(emailBody, emailSubject, name),
+
+      // Update timestamp
+      analysis_timestamp: new Date().toISOString(),
+      content_length: emailBody.length,
+    };
+
+    // Calculate final classification confidence
+    combinedData.final_confidence = calculateFinalConfidence(combinedData);
+
+    // Generate detailed explanation
+    combinedData.explanation = generateExplanation(combinedData);
+
+    // Add compliance flags
+    combinedData.compliance_flags = checkCompliance(emailBody, emailSubject);
+
+    return combinedData;
+  }
+
+  function analyzeEmailLocally(body, subject, email, name) {
+    const text = (subject + ' ' + body).toLowerCase();
+    let spamScore = 0;
+    let phishingScore = 0;
+    let promotionalScore = 0;
+    let transactionalScore = 0;
+
+    // SPAM indicators
+    const spamKeywords = [
+      'congratulations',
+      'winner',
+      'prize',
+      'lottery',
+      'free',
+      'guaranteed',
+      'risk-free',
+      'act now',
+      'limited time',
+      'urgent',
+      'important',
+      'attention',
+      'alert',
+      'click here',
+      'buy now',
+      'order now',
+      'discount',
+      'save big',
+      'cheap',
+      'viagra',
+      'cialis',
+      'pharmacy',
+      'prescription',
+      'enlarge',
+      'weight loss',
+      'nigerian',
+      'prince',
+      'inheritance',
+      'unclaimed',
+      'bank account',
+      'password',
+      'account suspended',
+      'verify',
+      'security alert',
+      'dear friend',
+      'dear customer',
+      'dear account holder',
+    ];
+
+    spamKeywords.forEach((keyword) => {
+      if (text.includes(keyword)) spamScore += 2;
+    });
+
+    // Phishing indicators
+    const phishingPatterns = [/login\s*(?:here|now)/i, /verify\s*(?:your|my)\s*account/i, /password\s*(?:reset|expired|change)/i, /suspended\s*account/i, /unauthorized\s*activity/i, /security\s*breach/i, /update\s*(?:your|my)\s*information/i, /confirm\s*(?:your|my)\s*identity/i];
+
+    phishingPatterns.forEach((pattern) => {
+      if (pattern.test(text)) phishingScore += 15;
+    });
+
+    // Promotional indicators
+    const promotionalKeywords = ['newsletter', 'subscribe', 'unsubscribe', 'marketing', 'promotion', 'sale', 'offer', 'deal', 'coupon', 'voucher', 'discount code', 'new product', 'announcement', 'launch', 'event', 'webinar', 'limited offer', 'exclusive', 'special offer', 'members only'];
+
+    promotionalKeywords.forEach((keyword) => {
+      if (text.includes(keyword)) promotionalScore += 3;
+    });
+
+    // Transactional indicators
+    const transactionalKeywords = ['order', 'invoice', 'receipt', 'payment', 'booking', 'reservation', 'confirmation', 'shipping', 'delivery', 'tracking', 'shipment', 'appointment', 'meeting', 'reminder', 'bill', 'statement', 'account', 'statement', 'balance', 'transaction'];
+
+    transactionalKeywords.forEach((keyword) => {
+      if (text.includes(keyword)) transactionalScore += 3;
+    });
+
+    // Link analysis
+    const links = body.match(/https?:\/\/[^\s]+/g) || [];
+    const suspiciousDomains = ['bit.ly', 'tinyurl', 'shorte.st', 'adf.ly', 'goo.gl'];
+
+    links.forEach((link) => {
+      if (suspiciousDomains.some((domain) => link.includes(domain))) {
+        spamScore += 10;
+        phishingScore += 10;
+      }
+    });
+
+    // Grammar/spelling analysis (simple)
+    const misspellings = body.match(/\b(?:recieve|seperate|definately|occured|tomm?orrow)\b/gi) || [];
+    spamScore += misspellings.length * 2;
+
+    // Urgency analysis
+    const urgencyWords = ['urgent', 'immediately', 'asap', 'right now', 'today only'];
+    let urgencyCount = 0;
+    urgencyWords.forEach((word) => {
+      if (text.includes(word)) urgencyCount++;
+    });
+    spamScore += urgencyCount * 5;
+
+    // Personalization check
+    const hasName = name && body.toLowerCase().includes(name.toLowerCase().split(' ')[0]);
+    const personalPronouns = ['you', 'your', 'yours'];
+    let personalCount = 0;
+    personalPronouns.forEach((pronoun) => {
+      const regex = new RegExp(`\\b${pronoun}\\b`, 'gi');
+      personalCount += (body.match(regex) || []).length;
+    });
+
+    const personalizationScore = hasName ? 30 : Math.min(personalCount * 2, 20);
+
+    return {
+      spamScore: Math.min(spamScore, 100),
+      phishingScore: Math.min(phishingScore, 100),
+      promotionalScore: Math.min(promotionalScore, 100),
+      transactionalScore: Math.min(transactionalScore, 100),
+      personalizationScore,
+      linkCount: links.length,
+      hasUnsubscribe: text.includes('unsubscribe') || text.includes('opt-out'),
+      hasPhone: /\b\d{3}[-.]?\d{3}[-.]?\d{4}\b/.test(body),
+      hasAddress: /\b\d+\s+[\w\s]+(?:street|st|avenue|ave|road|rd|boulevard|blvd|way)\b/i.test(body),
+      urgencyCount,
+      misspellingCount: misspellings.length,
+    };
+  }
+
+  function analyzeSender(email, name, body) {
+    const domain = email.split('@')[1] || '';
+    const localPart = email.split('@')[0] || '';
+
+    return {
+      email: email,
+      domain: domain,
+      local_part: localPart,
+      is_public_domain: isPublicEmailDomain(domain),
+      is_generic_sender: isGenericSender(localPart, name),
+      domain_age_indicator: assessDomainAge(domain),
+      sender_consistency: checkSenderConsistency(name, email, body),
+    };
+  }
+
+  function isPublicEmailDomain(domain) {
+    const publicDomains = ['gmail.com', 'yahoo.com', 'outlook.com', 'hotmail.com', 'aol.com', 'icloud.com', 'protonmail.com', 'zoho.com', 'yandex.com'];
+    return publicDomains.includes(domain.toLowerCase());
+  }
+
+  function isGenericSender(localPart, name) {
+    const genericSenders = ['info', 'support', 'sales', 'contact', 'hello', 'noreply', 'admin', 'newsletter', 'marketing', 'team', 'notifications'];
+
+    const localLower = localPart.toLowerCase();
+    const nameLower = name.toLowerCase();
+
+    return genericSenders.some((sender) => localLower.includes(sender) || nameLower.includes(sender));
+  }
+
+  function assessDomainAge(domain) {
+    // This is a simplified version - in production, you'd use a domain age API
+    const newDomains = ['xyz', 'online', 'site', 'top', 'club', 'shop'];
+    const tld = domain.split('.').pop() || '';
+
+    if (newDomains.includes(tld)) return 'likely_new';
+    if (['com', 'org', 'net', 'edu', 'gov'].includes(tld)) return 'likely_established';
+    return 'unknown';
+  }
+
+  function checkSenderConsistency(name, email, body) {
+    const emailName = email.split('@')[0].toLowerCase();
+    const bodyName = name.toLowerCase();
+
+    // Check if name appears in body
+    const nameInBody = body.toLowerCase().includes(bodyName.split(' ')[0]);
+
+    // Check email-name consistency patterns
+    const nameParts = bodyName.split(' ');
+    const firstName = nameParts[0] || '';
+    const lastName = nameParts.slice(-1)[0] || '';
+
+    const patterns = [`${firstName}.${lastName}`, `${firstName}${lastName}`, `${firstName.charAt(0)}${lastName}`, `${firstName}`];
+
+    const consistent = patterns.some((pattern) => emailName.includes(pattern.toLowerCase()));
+
+    return {
+      name_in_body: nameInBody,
+      email_name_consistent: consistent,
+      consistency_score: (nameInBody ? 40 : 0) + (consistent ? 60 : 0),
+    };
+  }
+
+  function calculateUppercaseRatio(text) {
+    const letters = text.replace(/[^a-zA-Z]/g, '');
+    if (letters.length === 0) return 0;
+
+    const uppercase = letters.replace(/[^A-Z]/g, '');
+    return (uppercase.length / letters.length) * 100;
+  }
+
+  function detectBehavioralPatterns(body, subject) {
+    const text = (subject + ' ' + body).toLowerCase();
+    const patterns = [];
+
+    if (/(?:click|tap)\s+(?:here|this|link|button)/i.test(text)) {
+      patterns.push('call_to_action_link');
+    }
+
+    if (/limited\s+time|offer\s+expires|only\s+\d+\s+left/i.test(text)) {
+      patterns.push('scarcity_tactic');
+    }
+
+    if (/\$\d+|\d+\s*%|\d+\s*off|discount|save|sale/i.test(text)) {
+      patterns.push('monetary_offer');
+    }
+
+    if (/urgent|important|alert|attention|warning/i.test(text)) {
+      patterns.push('urgency_tactic');
+    }
+
+    if (/(?:please|kindly)\s+(?:help|assist|reply)/i.test(text)) {
+      patterns.push('polite_request');
+    }
+
+    if (/unsubscribe|opt.?out|preference|manage subscription/i.test(text)) {
+      patterns.push('subscription_management');
+    }
+
+    return patterns;
+  }
+
+  function assessDomainReputation(email) {
+    const domain = email.split('@')[1] || '';
+
+    // Known spam domains (simplified list)
+    const spamDomains = ['spam4.me', 'trashmail.com', 'mailinator.com', 'guerrillamail.com', 'tempmail.com', 'yopmail.com', 'dispostable.com'];
+
+    if (spamDomains.includes(domain.toLowerCase())) {
+      return 'known_spam_domain';
+    }
+
+    // Professional domains
+    const professionalTLDs = ['com', 'org', 'net', 'edu', 'gov', 'io', 'ai', 'tech'];
+    const tld = domain.split('.').pop() || '';
+
+    if (professionalTLDs.includes(tld.toLowerCase())) {
+      return 'professional_domain';
+    }
+
+    // New/suspicious TLDs
+    const suspiciousTLDs = ['xyz', 'top', 'win', 'bid', 'download', 'stream'];
+    if (suspiciousTLDs.includes(tld.toLowerCase())) {
+      return 'suspicious_tld';
+    }
+
+    return 'neutral';
+  }
+
+  function calculateComprehensiveRisk(aiData, localAnalysis) {
+    let risk = 0;
+
+    // Base on AI classification
+    switch (aiData.email_type) {
+      case 'spam':
+        risk += 80;
+        break;
+      case 'promotional':
+        risk += 30;
+        break;
+      case 'transactional':
+        risk += 10;
+        break;
+      case 'personal':
+        risk += 5;
+        break;
+      case 'business':
+        risk += 15;
+        break;
+    }
+
+    // Add local analysis scores
+    risk += localAnalysis.spamScore * 0.2;
+    risk += localAnalysis.phishingScore * 0.3;
+
+    // Adjust for phishing risk
+    switch (aiData.phishing_risk) {
+      case 'critical':
+        risk += 40;
+        break;
+      case 'high':
+        risk += 30;
+        break;
+      case 'medium':
+        risk += 15;
+        break;
+      case 'low':
+        risk += 5;
+        break;
+    }
+
+    // Adjust for unsolicited
+    if (aiData.is_unsolicited) risk += 20;
+
+    // Adjust for urgency
+    if (aiData.is_urgent) risk += 10;
+
+    return Math.min(risk, 100);
+  }
+
+  function detectMatchedFilters(body, subject, email, name) {
+    const filters = [];
+    const text = (subject + ' ' + body).toLowerCase();
+
+    // Spam filters
+    if (/(?:viagra|cialis|penis|enlarge)/i.test(text)) filters.push('adult_content_filter');
+    if (/(?:lottery|winner|prize|jackpot)/i.test(text)) filters.push('lottery_scam_filter');
+    if (/(?:nigerian|prince|inheritance|unclaimed)/i.test(text)) filters.push('inheritance_scam_filter');
+    if (/password\s+reset|verify\s+account/i.test(text)) filters.push('account_verification_filter');
+
+    // Promotional filters
+    if (/newsletter|subscribe|unsubscribe/i.test(text)) filters.push('newsletter_filter');
+    if (/sale|discount|offer|coupon/i.test(text)) filters.push('promotional_offer_filter');
+    if (/webinar|event|conference/i.test(text)) filters.push('event_filter');
+
+    // Transactional filters
+    if (/order|invoice|receipt|payment/i.test(text)) filters.push('transaction_filter');
+    if (/shipping|delivery|tracking/i.test(text)) filters.push('shipping_filter');
+    if (/appointment|meeting|reminder/i.test(text)) filters.push('calendar_filter');
+
+    return filters;
+  }
+
+  function detectTimeSensitivity(body) {
+    const text = body.toLowerCase();
+    const patterns = [/today|tomorrow|this\s+week|immediately|asap/i, /deadline|due\s+by|expires|limited\s+time/i, /urgent|important|attention|alert/i];
+
+    return patterns.some((pattern) => pattern.test(text));
+  }
+
+  function detectExpiryDate(body) {
+    const datePatterns = [/\b\d{1,2}\/\d{1,2}\/\d{2,4}\b/g, /\b\d{1,2}\s+(?:jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)[a-z]*\s+\d{2,4}\b/gi, /\bexpires?\s+(?:on|by)?\s*[:]?\s*\d{1,2}\/\d{1,2}\/\d{2,4}\b/gi];
+
+    return datePatterns.some((pattern) => pattern.test(body.toLowerCase()));
+  }
+
+  function detectFollowUpPattern(body, subject) {
+    const text = (subject + ' ' + body).toLowerCase();
+    return /follow.?up|following.?up|checking.?in|touch.?base|re:.?re:/i.test(text);
+  }
+
+  function analyzeRelationshipContext(body, subject, name) {
+    const text = (subject + ' ' + body).toLowerCase();
+    const nameParts = name.toLowerCase().split(' ');
+    const firstName = nameParts[0] || '';
+
+    const indicators = {
+      uses_name: firstName && text.includes(firstName),
+      uses_personal_pronouns: /\b(?:i|me|my|mine|you|your|yours)\b/gi.test(text),
+      has_greeting: /^(?:hi|hello|hey|dear|greetings)\b/im.test(body),
+      has_signature: /(?:best|regards|sincerely|thanks|thank you)\s*[,]?\s*\n/im.test(body),
+      has_questions: /\?/.test(text) && /(?:can|could|would|will|do|are|is)\s+you/i.test(text),
+    };
+
+    const relationshipScore = Object.values(indicators).filter(Boolean).length * 20;
+
+    return {
+      ...indicators,
+      relationship_score: Math.min(relationshipScore, 100),
+      likely_known_sender: relationshipScore >= 40,
+    };
+  }
+
+  function calculateFinalConfidence(data) {
+    let confidence = data.email_type_confidence;
+
+    // Adjust based on local analysis
+    if (data.local_analysis.spamScore > 70 && data.email_type !== 'spam') {
+      confidence -= 20;
+    }
+
+    // Adjust based on phishing risk
+    if (data.phishing_risk === 'critical' || data.phishing_risk === 'high') {
+      confidence += 15;
+    }
+
+    // Adjust based on personalization
+    if (data.is_personalized) {
+      confidence += 10;
+    }
+
+    // Adjust based on content stats
+    if (data.content_stats.link_count > 5) {
+      confidence += 5;
+    }
+
+    return Math.max(0, Math.min(100, confidence));
+  }
+
+  function generateExplanation(data) {
+    const explanations = [];
+
+    if (data.email_type === 'spam') {
+      explanations.push('Classified as spam due to:');
+      if (data.spam_confidence > 70) explanations.push(`- High spam confidence (${data.spam_confidence}%)`);
+      if (data.phishing_risk !== 'none') explanations.push(`- ${data.phishing_risk} phishing risk`);
+      if (data.local_analysis.spamScore > 60) explanations.push('- Contains spam indicators');
+    }
+
+    if (data.email_type === 'promotional') {
+      explanations.push('Classified as promotional due to:');
+      if (data.is_commercial) explanations.push('- Commercial intent detected');
+      if (data.local_analysis.hasUnsubscribe) explanations.push('- Contains unsubscribe option');
+      if (data.local_analysis.promotionalScore > 30) explanations.push('- Promotional content detected');
+    }
+
+    if (data.key_indicators && data.key_indicators.length > 0) {
+      explanations.push('Key indicators:');
+      data.key_indicators.forEach((indicator) => {
+        explanations.push(`- ${indicator}`);
+      });
+    }
+
+    return explanations.join('\n');
+  }
+
+  function checkCompliance(body, subject) {
+    const text = (subject + ' ' + body).toLowerCase();
+    const flags = [];
+
+    // CAN-SPAM Act compliance (US)
+    if (text.includes('unsubscribe') || text.includes('opt-out')) {
+      flags.push('has_unsubscribe_option');
+    }
+
+    if (/\b\d{10}\b/.test(body.replace(/\D/g, ''))) {
+      flags.push('contains_phone_number');
+    }
+
+    if (/address\s*[:]?\s*\d+\s+[\w\s]+/i.test(body)) {
+      flags.push('contains_physical_address');
+    }
+
+    // GDPR indicators (EU)
+    if (/privacy\s+policy|gdpr|data\s+protection/i.test(text)) {
+      flags.push('gdpr_mentions');
+    }
+
+    if (/consent|opt.?in|permission/i.test(text)) {
+      flags.push('consent_mentions');
+    }
+
+    return flags;
+  }
+
+  function getDefaultEmailDetection(name, email, emailBody, emailSubject, error = null) {
+    const localAnalysis = analyzeEmailLocally(emailBody, emailSubject, email, name);
+
+    // Determine type based on local analysis
+    let emailType = 'ambiguous';
+    if (localAnalysis.spamScore > 70) emailType = 'spam';
+    else if (localAnalysis.promotionalScore > localAnalysis.transactionalScore && localAnalysis.promotionalScore > 30) emailType = 'promotional';
+    else if (localAnalysis.transactionalScore > 40) emailType = 'transactional';
+
+    const spamConfidence = localAnalysis.spamScore;
+    const phishingRisk = localAnalysis.phishingScore > 50 ? 'medium' : 'low';
+
+    return {
+      success: false,
+      email_type: emailType,
+      email_type_confidence: Math.max(50, spamConfidence),
+      email_subtype: 'personal_message',
+
+      spam_confidence: spamConfidence,
+      phishing_risk: phishingRisk,
+      malware_risk: 'none',
+
+      is_unsolicited: true,
+      is_commercial: localAnalysis.promotionalScore > 30,
+      is_urgent: localAnalysis.urgencyCount > 0,
+      is_personalized: localAnalysis.personalizationScore > 20,
+
+      sender_legitimacy: 'unknown',
+      sender_intent: 'unknown',
+
+      contains_links: localAnalysis.linkCount > 0,
+      contains_attachments: false,
+      contains_unsubscribe: localAnalysis.hasUnsubscribe,
+      contains_phone_number: localAnalysis.hasPhone,
+      contains_address: localAnalysis.hasAddress,
+
+      language_quality: localAnalysis.misspellingCount > 3 ? 'poor' : 'average',
+      urgency_level: localAnalysis.urgencyCount > 2 ? 'high' : 'low',
+      personalization_score: localAnalysis.personalizationScore,
+
+      suggested_action: emailType === 'spam' ? 'mark_as_spam' : 'keep_in_inbox',
+      auto_filter_suggestion: emailType === 'spam' ? 'spam_filter' : 'no_filter',
+      inbox_priority: emailType === 'spam' ? 'ignore' : 'normal',
+
+      key_indicators: ['Local analysis only - API failed'],
+      risk_factors: [],
+      legitimacy_signals: [],
+
+      analysis_timestamp: new Date().toISOString(),
+      content_length: emailBody.length,
+      analysis_complexity: 'simple',
+
+      // Enhanced fields
+      local_analysis: localAnalysis,
+      sender_analysis: analyzeSender(email, name, emailBody),
+      content_stats: {
+        word_count: (emailBody.match(/\S+/g) || []).length,
+        sentence_count: (emailBody.match(/[.!?]+/g) || []).length,
+        link_count: localAnalysis.linkCount,
+        uppercase_ratio: calculateUppercaseRatio(emailBody),
+        exclamation_count: (emailBody.match(/!/g) || []).length,
+        dollar_sign_count: (emailBody.match(/\$/g) || []).length,
+        phone_patterns: (emailBody.match(/\b\d{3}[-.]?\d{3}[-.]?\d{4}\b/g) || []).length,
+      },
+
+      comprehensive_risk_score: calculateComprehensiveRisk({ email_type: emailType, phishing_risk: phishingRisk, is_unsolicited: true, is_urgent: localAnalysis.urgencyCount > 0 }, localAnalysis),
+
+      final_confidence: Math.max(50, spamConfidence),
+      explanation: 'Default analysis due to API failure',
+      error: error || 'API call failed',
+    };
+  }
+
+  const detection_ret = await submit_chat_gpt_prompt({
+    uid,
+    prompt: `Analyze this email and determine if it's SPAM, PROMOTIONAL, TRANSACTIONAL, or PERSONAL/BUSINESS communication.
+
+FROM: "${name}" <${email}>
+SUBJECT: "${email_subject}"
+BODY: "${email_body.substring(0, 800)}${email_body.length > 800 ? '...' : ''}"
+
+ANALYSIS CRITERIA:
+
+SPAM INDICATORS:
+- Unsolicited commercial content
+- Phishing attempts or suspicious links
+- Poor grammar/spelling
+- Urgent/panic-inducing language
+- Requests for personal information
+- Too good to be true offers
+- Hidden/unclear sender identity
+- Multiple recipient addresses visible
+- Stock/"spammy" subject lines
+
+PROMOTIONAL INDICATORS:
+- Marketing/sales content
+- Product announcements
+- Newsletter content
+- Discount/coupon offers
+- Event invitations (commercial)
+- Company updates (marketing focused)
+- Clear opt-out/unsubscribe option
+- Professional branding/templates
+- Call-to-action buttons
+
+TRANSACTIONAL INDICATORS:
+- Order confirmations
+- Shipping notifications
+- Invoice/billing
+- Account notifications
+- Password resets
+- Booking confirmations
+- Appointment reminders
+- Payment receipts
+- Service updates
+
+PERSONAL/BUSINESS INDICATORS:
+- Direct communication to you
+- Known sender relationship
+- Work/project related
+- Personal conversations
+- One-on-one correspondence
+- Contains your name specifically
+- Contextually relevant to you
+
+ADDITIONAL FACTORS TO CONSIDER:
+- Sender reputation (company vs personal)
+- Your relationship with sender
+- Email formatting quality
+- Personalization level
+- Expected vs unexpected content
+- Action requested (if any)
+
+PROVIDE DETAILED ANALYSIS WITH CONFIDENCE SCORES.`,
+    model: 'gpt-5-nano',
+    response_format: z.object({
+      // Primary Classification
+      email_type: z.enum(['spam', 'promotional', 'transactional', 'personal', 'business', 'ambiguous']),
+      email_type_confidence: z.number().min(0).max(100),
+
+      // Sub-classification
+      email_subtype: z.enum([
+        // Spam types
+        'phishing_attempt',
+        'scam_offer',
+        'malware_risk',
+        'adult_content',
+        'financial_scam',
+        'lottery_scam',
+        'inheritance_scam',
+        'romance_scam',
+        'tech_support_scam',
+
+        // Promotional types
+        'marketing_newsletter',
+        'product_announcement',
+        'discount_offer',
+        'event_invitation',
+        'company_update',
+        'blog_newsletter',
+        'educational_content',
+        'lead_magnet',
+
+        // Transactional types
+        'order_confirmation',
+        'shipping_notification',
+        'invoice_billing',
+        'payment_receipt',
+        'account_verification',
+        'password_reset',
+        'appointment_reminder',
+        'service_notification',
+
+        // Personal/Business types
+        'personal_message',
+        'work_collaboration',
+        'client_communication',
+        'team_announcement',
+        'meeting_invitation',
+        'project_update',
+        'direct_inquiry',
+        'networking_request',
+      ]),
+
+      // Risk Assessment
+      spam_confidence: z.number().min(0).max(100).describe('Confidence this is spam'),
+      phishing_risk: z.enum(['none', 'low', 'medium', 'high', 'critical']),
+      malware_risk: z.enum(['none', 'low', 'medium', 'high']),
+
+      // Content Analysis
+      is_unsolicited: z.boolean().describe('Email was not requested/expected'),
+      is_commercial: z.boolean().describe('Contains commercial intent'),
+      is_urgent: z.boolean().describe('Uses urgent/time-sensitive language'),
+      is_personalized: z.boolean().describe('Content is personalized to recipient'),
+
+      // Sender Analysis
+      sender_legitimacy: z.enum(['verified', 'likely_legitimate', 'suspicious', 'likely_fake', 'unknown']),
+      sender_intent: z.enum(['inform', 'sell', 'scam', 'build_relationship', 'request_action', 'unknown']),
+
+      // Content Characteristics
+      contains_links: z.boolean(),
+      contains_attachments: z.boolean(),
+      contains_unsubscribe: z.boolean(),
+      contains_phone_number: z.boolean(),
+      contains_address: z.boolean(),
+
+      // Language Analysis
+      language_quality: z.enum(['excellent', 'good', 'average', 'poor', 'spammy']),
+      urgency_level: z.enum(['none', 'low', 'medium', 'high', 'extreme']),
+      personalization_score: z.number().min(0).max(100).describe('How personalized the content is'),
+
+      // Action Recommendations
+      suggested_action: z.enum(['delete_immediately', 'mark_as_spam', 'move_to_promotions', 'respond_politely', 'follow_up', 'archive', 'keep_in_inbox', 'add_to_contacts', 'report_phishing']),
+
+      // Filter Recommendations
+      auto_filter_suggestion: z.enum(['spam_filter', 'promotions_filter', 'social_filter', 'updates_filter', 'primary_inbox', 'no_filter']),
+
+      // Priority
+      inbox_priority: z.enum(['critical', 'high', 'normal', 'low', 'ignore']),
+
+      // Detailed Analysis
+      key_indicators: z.array(z.string()).describe('Key factors influencing classification'),
+      risk_factors: z.array(z.string()).describe('Specific risks identified'),
+      legitimacy_signals: z.array(z.string()).describe('Signals of legitimate communication'),
+
+      // Metadata
+      analysis_timestamp: z.string(),
+      content_length: z.number().describe('Length of email body analyzed'),
+      analysis_complexity: z.enum(['simple', 'moderate', 'complex', 'ambiguous']),
+    }),
+    metadata: {
+      func: 'detect_email_type',
+      sender_name: name,
+      sender_email: email,
+      subject_length: email_subject?.length || 0,
+      body_length: email_body?.length || 0,
+      body_preview_hash: await hashString(email_body.substring(0, 200)),
+    },
+    account_profile_info,
+    tools: [{ type: 'web_search_preview' }],
+  });
+
+  try {
+    if (detection_ret.code > -1) {
+      const data = typeof detection_ret.data === 'string' ? JSON.parse(detection_ret.data) : detection_ret.data;
+
+      // Enhance with additional analysis
+      const enhancedData = enhanceEmailDetection(data, name, email, email_body, email_subject);
+
+      return {
+        success: true,
+        ...enhancedData,
+      };
+    } else {
+      console.error('Email detection API call failed:', detection_ret);
+      return getDefaultEmailDetection(name, email, email_body, email_subject);
+    }
+  } catch (error) {
+    console.error('Error in detect_email_type:', error);
+    return getDefaultEmailDetection(name, email, email_body, email_subject, error.message);
+  }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xuda.io/ai_module",
-  "version": "1.1.4680",
+  "version": "1.1.4682",
   "description": "Xuda AI Module",
   "main": "index.mjs",
   "type": "module",