@xuda.io/ai_module 1.1.4679 → 1.1.4680

package/index.mjs

@@ -9729,3 +9729,633 @@ export const get_person_info = async function (uid, name, email, account_profile
     return getDefaultPersonInfo(name, email, email_context, error.message);
   }
 };
+
+export const analyze_email_account_type = async function (uid, name, email, account_profile_info, email_context = '') {
+  // ========== HELPER FUNCTIONS ==========
+
+  function enhanceEmailAnalysis(data, name, email, emailContext) {
+    const domain = email.split('@')[1] || '';
+    const localPart = email.split('@')[0] || '';
+    const nameParts = name.toLowerCase().split(/\s+/);
+    const firstName = nameParts[0] || '';
+    const lastName = nameParts.slice(-1)[0] || '';
+
+    // Enhanced business company detection
+    if (data.account_type === 'business' && !data.business_company_name) {
+      data.business_company_name = inferCompanyFromDomain(domain);
+    }
+
+    // Enhanced person detection
+    if (!data.is_real_person) {
+      data.is_real_person = detectRealPerson(localPart, name, domain);
+    }
+
+    if (!data.person_name_in_email) {
+      data.person_name_in_email = checkNameInEmail(localPart, firstName, lastName);
+    }
+
+    // Enhanced pattern analysis
+    if (data.email_pattern === 'unknown') {
+      data.email_pattern = analyzeEmailPattern(localPart, domain);
+    }
+
+    // Enhanced personal provider detection
+    if (data.account_type === 'personal' && !data.personal_account_provider) {
+      data.personal_account_provider = identifyPersonalProvider(domain);
+    }
+
+    // Enhanced risk assessment
+    if (data.spam_risk_level === 'unknown') {
+      data.spam_risk_level = assessSpamRisk(localPart, domain, data.account_type);
+    }
+
+    // Enhanced activity assessment
+    if (!data.is_likely_active) {
+      data.is_likely_active = assessEmailActivity(localPart, domain, data.account_type, data.business_account_category);
+    }
+
+    // Add domain analysis
+    data.domain_analysis = {
+      domain: domain,
+      is_public_provider: isPublicEmailProvider(domain),
+      is_custom_domain: isCustomDomain(domain),
+      is_free_email: isFreeEmailDomain(domain),
+      is_education: isEducationDomain(domain),
+      is_government: isGovernmentDomain(domain),
+      tld: domain.split('.').pop() || '',
+    };
+
+    // Add name-email correlation score
+    data.name_email_correlation = calculateNameEmailCorrelation(localPart, firstName, lastName);
+
+    // Add professional score
+    data.professional_score = calculateProfessionalScore(data);
+
+    // Add structured recommendations
+    data.recommendations = generateRecommendations(data);
+
+    // Add verification suggestions
+    data.verification_suggestions = generateVerificationSuggestions(data, emailContext);
+
+    // Add timestamp
+    data.analysis_timestamp = data.analysis_timestamp || new Date().toISOString();
+
+    return data;
+  }
+
+  function inferCompanyFromDomain(domain) {
+    if (!domain) return 'Unknown';
+
+    // Remove common TLDs and public providers
+    const baseDomain = domain.replace(/\.(com|org|net|co|io|ai|tech|app|dev)$/, '');
+
+    // Remove common subdomains
+    const cleanDomain = baseDomain.replace(/^(mail\.|email\.|webmail\.|smtp\.|mx\.|imap\.)/, '').replace(/\.(com|org|net)$/, '');
+
+    // Convert to readable company name
+    const companyName = cleanDomain
+      .split(/[\.\-]/)
+      .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+      .join(' ');
+
+    return companyName || 'Unknown';
+  }
+
+  function detectRealPerson(localPart, name, domain) {
+    // Check for generic email addresses
+    const genericPatterns = [
+      'info',
+      'support',
+      'sales',
+      'contact',
+      'hello',
+      'noreply',
+      'no-reply',
+      'admin',
+      'administrator',
+      'webmaster',
+      'postmaster',
+      'hostmaster',
+      'abuse',
+      'security',
+      'billing',
+      'accounts',
+      'finance',
+      'hr',
+      'humanresources',
+      'marketing',
+      'pr',
+      'press',
+      'media',
+      'legal',
+      'it',
+      'techsupport',
+      'help',
+      'service',
+      'customerservice',
+      'feedback',
+      'inquiries',
+    ];
+
+    const localLower = localPart.toLowerCase();
+
+    // If it matches generic patterns, likely not a real person
+    if (genericPatterns.some((pattern) => localLower === pattern || localLower.startsWith(pattern + '.') || localLower.endsWith('.' + pattern))) {
+      return false;
+    }
+
+    // Check for role-based patterns
+    const rolePatterns = ['ceo', 'cto', 'cfo', 'coo', 'cm', 'director', 'manager', 'head', 'lead', 'senior', 'junior', 'associate', 'analyst', 'engineer', 'developer', 'designer', 'architect', 'consultant', 'advisor'];
+
+    // If contains role patterns but not name, might be generic
+    const hasRolePattern = rolePatterns.some((role) => localLower.includes(role));
+    const hasNameElements = checkNameInEmail(localPart, name.toLowerCase().split(' ')[0], name.toLowerCase().split(' ').slice(-1)[0]);
+
+    if (hasRolePattern && !hasNameElements) {
+      return false;
+    }
+
+    // Check for numeric-only or random strings
+    if (/^\d+$/.test(localPart) || /^[a-f0-9]{32}$/.test(localPart)) {
+      return false;
+    }
+
+    // Check for obvious spam patterns
+    if (localLower.includes('spam') || localLower.includes('bot') || localLower.includes('test')) {
+      return false;
+    }
+
+    return true;
+  }
+
+  function checkNameInEmail(localPart, firstName, lastName) {
+    if (!firstName && !lastName) return false;
+
+    const localLower = localPart.toLowerCase();
+    const firstLower = firstName.toLowerCase();
+    const lastLower = lastName.toLowerCase();
+
+    // Check various name patterns
+    const patterns = [
+      `${firstLower}.${lastLower}`, // john.doe
+      `${firstLower}${lastLower}`, // johndoe
+      `${firstLower.charAt(0)}${lastLower}`, // jdoe
+      `${firstLower}_${lastLower}`, // john_doe
+      `${firstLower}-${lastLower}`, // john-doe
+      `${lastLower}.${firstLower}`, // doe.john
+      `${firstLower.charAt(0)}.${lastLower}`, // j.doe
+      `${lastLower}${firstLower}`, // doejohn
+      `${firstLower}`, // john
+      `${lastLower}`, // doe
+    ];
+
+    return patterns.some((pattern) => localLower === pattern || localLower.startsWith(pattern + '.') || localLower.includes('.' + pattern));
+  }
+
+  function analyzeEmailPattern(localPart, domain) {
+    const localLower = localPart.toLowerCase();
+
+    // Common business patterns
+    if (/^[a-z]+\.[a-z]+$/.test(localLower)) return 'first.last@company.com';
+    if (/^[a-z]+[a-z]+$/.test(localLower) && localLower.length > 5) return 'firstlast@company.com';
+    if (/^[a-z]\.[a-z]+$/.test(localLower)) return 'f.last@company.com';
+    if (/^[a-z][a-z]+$/.test(localLower) && localLower.length <= 5) return 'flast@company.com';
+    if (/^[a-z]+$/.test(localLower) && localLower.length <= 8) return 'first@company.com';
+    if (/^[a-z]+\.[a-z]+\.[a-z]+$/.test(localLower)) return 'first.m.last@company.com';
+
+    // Generic patterns
+    if (/^(info|support|sales|contact|hello)$/.test(localLower)) return 'role@company.com';
+    if (/^(hr|finance|marketing|it|legal)$/.test(localLower)) return 'department@company.com';
+
+    // Personal patterns
+    if (isPublicEmailProvider(domain)) {
+      if (/^[a-z]+\.[a-z]+$/.test(localLower)) return 'first.last@domain.com';
+      if (/^[a-z]+[0-9]+$/.test(localLower)) return 'personal@provider.com';
+      return 'custom@personal.com';
+    }
+
+    return 'unknown';
+  }
+
+  function identifyPersonalProvider(domain) {
+    const providers = {
+      'gmail.com': 'Google Gmail',
+      'googlemail.com': 'Google Gmail',
+      'outlook.com': 'Microsoft Outlook',
+      'hotmail.com': 'Microsoft Hotmail',
+      'live.com': 'Microsoft Live',
+      'yahoo.com': 'Yahoo Mail',
+      'ymail.com': 'Yahoo Mail',
+      'aol.com': 'AOL Mail',
+      'icloud.com': 'Apple iCloud',
+      'me.com': 'Apple iCloud',
+      'mac.com': 'Apple iCloud',
+      'protonmail.com': 'ProtonMail',
+      'proton.me': 'ProtonMail',
+      'zoho.com': 'Zoho Mail',
+      'yandex.com': 'Yandex Mail',
+      'mail.com': 'Mail.com',
+      'gmx.com': 'GMX Mail',
+    };
+
+    return providers[domain.toLowerCase()] || 'Custom/Unknown';
+  }
+
+  function isPublicEmailProvider(domain) {
+    const publicProviders = ['gmail.com', 'googlemail.com', 'outlook.com', 'hotmail.com', 'live.com', 'yahoo.com', 'ymail.com', 'aol.com', 'icloud.com', 'me.com', 'mac.com', 'protonmail.com', 'proton.me', 'zoho.com', 'yandex.com', 'mail.com', 'gmx.com'];
+
+    return publicProviders.includes(domain.toLowerCase());
+  }
+
+  function isFreeEmailDomain(domain) {
+    const freeDomains = ['gmail.com', 'yahoo.com', 'outlook.com', 'hotmail.com', 'aol.com', 'mail.com', 'gmx.com', 'yandex.com', 'zoho.com'];
+
+    return freeDomains.includes(domain.toLowerCase());
+  }
+
+  function isCustomDomain(domain) {
+    const publicProviders = ['gmail.com', 'googlemail.com', 'outlook.com', 'hotmail.com', 'live.com', 'yahoo.com', 'ymail.com', 'aol.com', 'icloud.com', 'me.com', 'mac.com', 'protonmail.com', 'proton.me', 'zoho.com', 'yandex.com', 'mail.com', 'gmx.com', 'edu', 'gov', 'mil', 'org', 'net'];
+
+    return !publicProviders.some((provider) => domain.toLowerCase().includes(provider));
+  }
+
+  function isEducationDomain(domain) {
+    return domain.toLowerCase().endsWith('.edu') || domain.toLowerCase().includes('.ac.');
+  }
+
+  function isGovernmentDomain(domain) {
+    return domain.toLowerCase().endsWith('.gov') || domain.toLowerCase().endsWith('.mil');
+  }
+
+  function assessSpamRisk(localPart, domain, accountType) {
+    const localLower = localPart.toLowerCase();
+
+    // High risk indicators
+    if (localLower.includes('spam') || localLower.includes('bot')) return 'high';
+    if (/^[a-f0-9]{32}$/.test(localLower)) return 'high'; // MD5 hash-like
+    if (/^\d+$/.test(localLower)) return 'high'; // Numbers only
+    if (localLower.includes('temp') || localLower.includes('throwaway')) return 'high';
+
+    // Medium risk indicators
+    if (localLower.includes('test') || localLower.includes('demo')) return 'medium';
+    if (accountType === 'personal' && localLower.includes('+')) return 'medium'; // Plus addressing
+
+    // Check disposable email domains
+    if (isDisposableDomain(domain)) return 'high';
+
+    return 'low';
+  }
+
+  function isDisposableDomain(domain) {
+    // Common disposable/temporary email domains
+    const disposableDomains = ['tempmail.com', 'mailinator.com', 'guerrillamail.com', '10minutemail.com', 'yopmail.com', 'trashmail.com', 'dispostable.com', 'fakeinbox.com', 'throwawaymail.com', 'temp-mail.org'];
+
+    return disposableDomains.some((d) => domain.toLowerCase().includes(d));
+  }
+
+  function assessEmailActivity(localPart, domain, accountType, businessCategory) {
+    // Generic/role emails are usually monitored
+    if (accountType === 'business' && ['generic_role', 'department', 'catch_all'].includes(businessCategory)) {
+      return true;
+    }
+
+    // Personal emails with name patterns are likely active
+    if (accountType === 'personal' && /^[a-z]+\.[a-z]+$/.test(localPart.toLowerCase())) {
+      return true;
+    }
+
+    // Education and government emails are usually active
+    if (isEducationDomain(domain) || isGovernmentDomain(domain)) {
+      return true;
+    }
+
+    // Disposable domains are usually inactive after short period
+    if (isDisposableDomain(domain)) {
+      return false;
+    }
+
+    // Default assumption
+    return true;
+  }
+
+  function calculateNameEmailCorrelation(localPart, firstName, lastName) {
+    if (!firstName && !lastName) return 0;
+
+    let score = 0;
+    const localLower = localPart.toLowerCase();
+    const firstLower = firstName.toLowerCase();
+    const lastLower = lastName.toLowerCase();
+
+    // Exact name patterns
+    if (localLower === `${firstLower}.${lastLower}`) score += 40;
+    if (localLower === `${firstLower}${lastLower}`) score += 35;
+    if (localLower === `${firstLower.charAt(0)}${lastLower}`) score += 30;
+    if (localLower === `${firstLower}_${lastLower}`) score += 25;
+
+    // Partial matches
+    if (localLower.includes(firstLower)) score += 15;
+    if (localLower.includes(lastLower)) score += 15;
+
+    // Initial matches
+    if (localLower.startsWith(firstLower.charAt(0))) score += 10;
+
+    // Length consideration (shorter emails with names are better)
+    if (localLower.length <= 20) score += 5;
+
+    return Math.min(score, 100);
+  }
+
+  function calculateProfessionalScore(data) {
+    let score = 50; // Base score
+
+    // Account type weights
+    if (data.account_type === 'business') score += 30;
+    else if (data.account_type === 'personal') score += 10;
+
+    // Real person bonus
+    if (data.is_real_person) score += 20;
+
+    // Active email bonus
+    if (data.is_likely_active) score += 15;
+
+    // Low spam risk bonus
+    if (data.spam_risk_level === 'low') score += 10;
+    else if (data.spam_risk_level === 'high') score -= 20;
+
+    // Name-email correlation bonus
+    score += (data.name_email_correlation / 100) * 20;
+
+    // Business category bonus
+    if (data.business_account_category === 'personal_employee') score += 15;
+
+    return Math.max(0, Math.min(100, score));
+  }
+
+  function generateRecommendations(data) {
+    const recommendations = [];
+
+    if (data.account_type === 'business' && data.is_real_person) {
+      if (data.business_account_category === 'personal_employee') {
+        recommendations.push('Ideal for direct professional outreach');
+        recommendations.push('Suitable for sales, recruitment, and partnership discussions');
+      } else if (data.business_account_category === 'department') {
+        recommendations.push('Best for department-specific inquiries');
+        recommendations.push('Use for customer support or service requests');
+      }
+    } else if (data.account_type === 'personal') {
+      recommendations.push('Suitable for networking and personal connections');
+      recommendations.push('May be used for freelance or consulting work');
+    }
+
+    if (data.spam_risk_level === 'high') {
+      recommendations.push('Consider verifying before important communications');
+    }
+
+    if (!data.is_likely_active) {
+      recommendations.push('Email may not be actively monitored');
+    }
+
+    return recommendations;
+  }
+
+  function generateVerificationSuggestions(data, emailContext) {
+    const suggestions = [];
+
+    if (data.account_type === 'business' && !data.business_company_name) {
+      suggestions.push('Verify company name through LinkedIn or company website');
+    }
+
+    if (!data.is_real_person && data.account_type === 'business') {
+      suggestions.push('Check if this is a role-based email that forwards to individuals');
+    }
+
+    if (data.spam_risk_level === 'medium' || data.spam_risk_level === 'high') {
+      suggestions.push('Send verification email before important communications');
+    }
+
+    if (data.domain_analysis.is_custom_domain) {
+      suggestions.push('Check company website for email format patterns');
+    }
+
+    return suggestions;
+  }
+
+  function getDefaultEmailAnalysis(name, email, emailContext = '', error = null) {
+    const domain = email.split('@')[1] || '';
+    const localPart = email.split('@')[0] || '';
+    const nameParts = name.toLowerCase().split(/\s+/);
+    const firstName = nameParts[0] || '';
+    const lastName = nameParts.slice(-1)[0] || '';
+
+    const isPublicProvider = isPublicEmailProvider(domain);
+    const accountType = isPublicProvider ? 'personal' : 'business';
+    const isRealPerson = detectRealPerson(localPart, name, domain);
+
+    return {
+      success: false,
+      account_type: accountType,
+      account_type_confidence: 70,
+
+      personal_account_provider: isPublicProvider ? identifyPersonalProvider(domain) : undefined,
+      personal_account_type: 'unknown',
+      personal_account_age_indicator: 'unknown',
+
+      business_company_name: !isPublicProvider ? inferCompanyFromDomain(domain) : undefined,
+      business_company_domain: !isPublicProvider ? domain : undefined,
+      business_account_category: !isPublicProvider ? (isRealPerson ? 'personal_employee' : 'generic_role') : undefined,
+      business_account_role: undefined,
+      business_department: undefined,
+
+      is_real_person: isRealPerson,
+      person_name_in_email: checkNameInEmail(localPart, firstName, lastName),
+      person_title_inferred: undefined,
+
+      email_pattern: analyzeEmailPattern(localPart, domain),
+
+      context_supports_business: undefined,
+      context_supports_personal: undefined,
+      context_company_mentions: [],
+
+      is_high_quality_contact: isRealPerson && !isPublicProvider,
+      is_likely_active: true,
+      spam_risk_level: assessSpamRisk(localPart, domain, accountType),
+
+      suggested_use_case: isRealPerson && !isPublicProvider ? 'sales_outreach' : 'networking',
+
+      analysis_timestamp: new Date().toISOString(),
+      analysis_notes: ['Default analysis due to API failure'],
+
+      // Enhanced fields
+      domain_analysis: {
+        domain: domain,
+        is_public_provider: isPublicProvider,
+        is_custom_domain: isCustomDomain(domain),
+        is_free_email: isFreeEmailDomain(domain),
+        is_education: isEducationDomain(domain),
+        is_government: isGovernmentDomain(domain),
+        tld: domain.split('.').pop() || '',
+      },
+
+      name_email_correlation: calculateNameEmailCorrelation(localPart, firstName, lastName),
+      professional_score: calculateProfessionalScore({
+        account_type: accountType,
+        is_real_person: isRealPerson,
+        is_likely_active: true,
+        spam_risk_level: assessSpamRisk(localPart, domain, accountType),
+        name_email_correlation: calculateNameEmailCorrelation(localPart, firstName, lastName),
+        business_account_category: !isPublicProvider ? (isRealPerson ? 'personal_employee' : 'generic_role') : undefined,
+      }),
+
+      recommendations: generateRecommendations({
+        account_type: accountType,
+        is_real_person: isRealPerson,
+        business_account_category: !isPublicProvider ? (isRealPerson ? 'personal_employee' : 'generic_role') : undefined,
+        spam_risk_level: assessSpamRisk(localPart, domain, accountType),
+        is_likely_active: true,
+      }),
+
+      verification_suggestions: generateVerificationSuggestions(
+        {
+          account_type: accountType,
+          business_company_name: !isPublicProvider ? inferCompanyFromDomain(domain) : undefined,
+          is_real_person: isRealPerson,
+          spam_risk_level: assessSpamRisk(localPart, domain, accountType),
+          domain_analysis: { is_custom_domain: isCustomDomain(domain) },
+        },
+        emailContext,
+      ),
+
+      error: error || 'API call failed',
+    };
+  }
+
+  const analysis_ret = await submit_chat_gpt_prompt({
+    uid,
+    prompt: `Analyze this email account: "${email}" for person: "${name}"
+
+EMAIL CONTEXT (if provided):
+"${email_context.substring(0, 400)}${email_context.length > 400 ? '...' : ''}"
+
+ANALYSIS TASKS:
+1. Determine if this is a PERSONAL or BUSINESS email account
+2. For BUSINESS accounts:
+   - Identify the company/organization
+   - Determine if this email belongs to a REAL PERSON at the company
+   - Or if it's a generic/role-based account
+3. For PERSONAL accounts:
+   - Identify which personal email provider is used
+   - Determine if it's likely a primary or secondary personal account
+
+ANALYSIS CRITERIA:
+BUSINESS EMAIL INDICATORS:
+- Domain matches a known company (not public email providers)
+- Email format matches company naming conventions
+- Email is mentioned in professional context
+- Contains company-specific signature or details
+
+PERSONAL EMAIL INDICATORS:
+- Domain is from public email providers (gmail.com, outlook.com, yahoo.com, etc.)
+- Email format is personal/creative
+- No company affiliation in context
+- Used for personal communications
+
+PERSON VS GENERIC BUSINESS ACCOUNT:
+- PERSON: Contains personal name elements (john.doe@company.com)
+- GENERIC: info@, support@, sales@, contact@, hello@, noreply@, etc.
+- DEPARTMENT: hr@, finance@, marketing@, it@, etc.
+
+COMPANY DETECTION:
+- Extract company from email domain when possible
+- Use name patterns to identify likely companies
+- Consider email context for company references
+
+PROVIDE DETAILED ANALYSIS WITH CONFIDENCE LEVELS.`,
+    model: 'gpt-4o-minai',
+    response_format: z.object({
+      // Primary Classification
+      account_type: z.enum(['personal', 'business', 'ambiguous']),
+      account_type_confidence: z.number().min(0).max(100),
+
+      // Personal Account Details
+      personal_account_provider: z.string().optional().describe('Email provider for personal accounts'),
+      personal_account_type: z.enum(['primary', 'secondary', 'disposable', 'unknown']).optional(),
+      personal_account_age_indicator: z.enum(['new', 'established', 'old', 'unknown']).optional(),
+
+      // Business Account Details
+      business_company_name: z.string().optional().describe('Company name if business account'),
+      business_company_domain: z.string().optional().describe('Company domain'),
+      business_account_category: z.enum(['personal_employee', 'generic_role', 'department', 'catch_all', 'unknown']).optional(),
+      business_account_role: z.string().optional().describe('Role suggested by email address'),
+      business_department: z.string().optional().describe('Department if applicable'),
+
+      // Person Analysis
+      is_real_person: z.boolean().describe('Whether email belongs to a real person'),
+      person_name_in_email: z.boolean().describe("Whether person's name appears in email address"),
+      person_title_inferred: z.string().optional().describe('Inferred job title from email pattern'),
+
+      // Email Pattern Analysis
+      email_pattern: z.enum([
+        'first.last@company.com',
+        'first.last@domain.com',
+        'firstlast@company.com',
+        'flast@company.com',
+        'first@company.com',
+        'f.last@company.com',
+        'initial.last@company.com',
+        'role@company.com',
+        'department@company.com',
+        'info@company.com',
+        'generic@company.com',
+        'personal@provider.com',
+        'custom@personal.com',
+        'unknown',
+      ]),
+
+      // Context Analysis
+      context_supports_business: z.boolean().optional().describe('Email context suggests business use'),
+      context_supports_personal: z.boolean().optional().describe('Email context suggests personal use'),
+      context_company_mentions: z.array(z.string()).optional().describe('Companies mentioned in context'),
+
+      // Risk & Quality Assessment
+      is_high_quality_contact: z.boolean().describe('Good contact for professional outreach'),
+      is_likely_active: z.boolean().describe('Email likely actively monitored'),
+      spam_risk_level: z.enum(['low', 'medium', 'high', 'unknown']),
+
+      // Recommendations
+      suggested_use_case: z.enum(['sales_outreach', 'recruitment', 'customer_support', 'partnership', 'networking', 'personal_contact', 'avoid']),
+
+      // Metadata
+      analysis_timestamp: z.string().describe('When analysis was performed'),
+      analysis_notes: z.array(z.string()).optional().describe('Key observations from analysis'),
+    }),
+    metadata: {
+      func: 'analyze_email_account_type',
+      person_name: name,
+      person_email: email,
+      has_email_context: !!email_context,
+      email_length: email_context?.length || 0,
+    },
+    account_profile_info,
+    tools: [{ type: 'web_search_preview' }],
+  });
+
+  try {
+    if (analysis_ret.code > -1) {
+      const data = typeof analysis_ret.data === 'string' ? JSON.parse(analysis_ret.data) : analysis_ret.data;
+
+      // Enhance with additional analysis
+      const enhancedData = enhanceEmailAnalysis(data, name, email, email_context);
+
+      return {
+        success: true,
+        ...enhancedData,
+      };
+    } else {
+      console.error('Email analysis API call failed:', analysis_ret);
+      return getDefaultEmailAnalysis(name, email, email_context);
+    }
+  } catch (error) {
+    console.error('Error in analyze_email_account_type:', error);
+    return getDefaultEmailAnalysis(name, email, email_context, error.message);
+  }
+};

package/package.json

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