WhatsApp Business Automation: Service Catalog Integration with n8n and AI

// WhatsApp Business API Capabilities
const capabilities = {
  messaging: {
    text: "Rich text messages with formatting",
    media: "Images, documents, audio, video",
    interactive: "Buttons, lists, quick replies",
    templates: "Pre-approved message templates"
  },
  automation: {
    webhooks: "Real-time message events",
    workflows: "Automated response flows",
    ai_integration: "AI-powered conversations",
    catalog_sync: "Dynamic product/service catalogs"
  }
};

# Service-Based Business Automation
use_cases:
  customer_service:
    - Service inquiries and information
    - Quote requests and pricing
    - Appointment scheduling
    - Order status updates
  
  sales_automation:
    - Lead qualification
    - Product/service recommendations
    - Pricing and availability
    - Booking confirmations
  
  support_workflows:
    - FAQ responses
    - Technical support
    - Escalation handling
    - Follow-up sequences

# Requirements for official API
- Verified business account
- Facebook Business Manager
- Meta Business verification
- Approved message templates

# Application process
1. Create Facebook Business Manager account
2. Apply for WhatsApp Business API
3. Complete business verification
4. Set up webhook endpoint

// Popular WhatsApp API providers
const providers = {
  twilio: {
    endpoint: "https://api.twilio.com/2010-04-01/Accounts/",
    features: ["Easy setup", "Sandbox mode", "Good documentation"],
    pricing: "Pay per message"
  },
  
  360dialog: {
    endpoint: "https://waba.360dialog.io/v1/",
    features: ["Direct WhatsApp partner", "Template management"],
    pricing: "Monthly + per message"
  },
  
  chatapi: {
    endpoint: "https://api.chat-api.com/",
    features: ["Quick start", "Web interface", "Zapier integration"],
    pricing: "Monthly subscription"
  }
};

// n8n Webhook Configuration
{
  "webhook_url": "https://your-n8n-instance.com/webhook/whatsapp",
  "events": [
    "messages",
    "message_status",
    "message_template_status_update"
  ],
  "field": "messages",
  "includes": [
    "messages",
    "message_echoes",
    "message_status",
    "messaging_postbacks"
  ]
}

{
  "name": "WhatsApp Service Automation",
  "nodes": [
    {
      "parameters": {
        "httpMethod": "POST",
        "path": "whatsapp",
        "responseMode": "responseNode"
      },
      "id": "webhook-whatsapp",
      "name": "WhatsApp Webhook",
      "type": "n8n-nodes-base.webhook",
      "typeVersion": 1,
      "position": [250, 300]
    },
    {
      "parameters": {
        "conditions": {
          "string": [
            {
              "value1": "={{$json.entry[0].changes[0].value.messages[0].type}}",
              "value2": "text"
            }
          ]
        }
      },
      "id": "filter-text-messages",
      "name": "Filter Text Messages",
      "type": "n8n-nodes-base.if",
      "typeVersion": 1,
      "position": [450, 300]
    }
  ]
}

// n8n JavaScript Code Node
const incomingMessage = $input.first().json;
const message = incomingMessage.entry[0].changes[0].value.messages[0];

// Extract message details
const messageData = {
  from: message.from,
  messageId: message.id,
  timestamp: message.timestamp,
  text: message.text?.body || '',
  type: message.type,
  name: incomingMessage.entry[0].changes[0].value.contacts?.[0]?.profile?.name || 'Customer'
};

// Classify message intent
const intent = classifyIntent(messageData.text);

return {
  ...messageData,
  intent: intent,
  shouldRespond: true
};

function classifyIntent(text) {
  const lowerText = text.toLowerCase();
  
  if (lowerText.includes('price') || lowerText.includes('cost') || lowerText.includes('quote')) {
    return 'pricing_inquiry';
  } else if (lowerText.includes('book') || lowerText.includes('appointment') || lowerText.includes('schedule')) {
    return 'booking_request';
  } else if (lowerText.includes('service') || lowerText.includes('what do you offer')) {
    return 'service_inquiry';
  } else if (lowerText.includes('help') || lowerText.includes('support')) {
    return 'support_request';
  } else {
    return 'general_inquiry';
  }
}

-- Services table
CREATE TABLE services (
    id SERIAL PRIMARY KEY,
    name VARCHAR(255) NOT NULL,
    description TEXT,
    category VARCHAR(100),
    base_price DECIMAL(10,2),
    duration_minutes INTEGER,
    is_active BOOLEAN DEFAULT true,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

-- Service variations/packages
CREATE TABLE service_packages (
    id SERIAL PRIMARY KEY,
    service_id INTEGER REFERENCES services(id),
    package_name VARCHAR(255),
    description TEXT,
    price DECIMAL(10,2),
    features JSONB,
    is_popular BOOLEAN DEFAULT false
);

-- Pricing rules
CREATE TABLE pricing_rules (
    id SERIAL PRIMARY KEY,
    service_id INTEGER REFERENCES services(id),
    condition_type VARCHAR(50), -- 'quantity', 'duration', 'time_of_day'
    condition_value JSONB,
    price_modifier_type VARCHAR(20), -- 'percentage', 'fixed'
    price_modifier DECIMAL(10,2),
    is_active BOOLEAN DEFAULT true
);

-- Customer interactions
CREATE TABLE customer_interactions (
    id SERIAL PRIMARY KEY,
    phone_number VARCHAR(20),
    customer_name VARCHAR(255),
    message_text TEXT,
    intent VARCHAR(50),
    response_sent TEXT,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

-- Insert sample services
INSERT INTO services (name, description, category, base_price, duration_minutes) VALUES
('Database Consultation', 'Expert database architecture and optimization consultation', 'Consulting', 150.00, 60),
('Website Development', 'Custom website development with modern technologies', 'Development', 2500.00, NULL),
('API Integration', 'Third-party API integration and development', 'Development', 800.00, NULL),
('Server Setup', 'Production server setup and configuration', 'Infrastructure', 500.00, NULL);

-- Insert service packages
INSERT INTO service_packages (service_id, package_name, description, price, features) VALUES
(1, 'Basic Consultation', 'One-hour consultation call', 150.00, '["Database review", "Recommendations document"]'),
(1, 'Extended Analysis', 'Comprehensive database analysis', 400.00, '["3-hour analysis", "Detailed report", "Implementation guide"]'),
(2, 'Landing Page', 'Single page website', 800.00, '["Responsive design", "Contact form", "SEO optimization"]'),
(2, 'Business Website', 'Multi-page business website', 2500.00, '["Up to 10 pages", "CMS integration", "Analytics setup"]'),
(2, 'E-commerce Site', 'Full e-commerce solution', 5000.00, '["Product catalog", "Payment integration", "Admin panel"]');

// n8n OpenAI Node Configuration
const aiPrompt = `
You are a helpful business assistant for a database and web development company.
Customer message: "${$json.text}"
Customer name: "${$json.name}"
Intent: "${$json.intent}"

Available services:
- Database Consultation ($150-400)
- Website Development ($800-5000)
- API Integration ($800)
- Server Setup ($500)

Respond professionally and helpfully. If they're asking about pricing, mention we can provide a detailed quote. If they want to book, guide them to schedule a consultation.

Keep responses under 160 characters when possible for WhatsApp.
`;

// Function to get AI response
async function getAIResponse(customerMessage, intent, availableServices) {
  const prompt = `
    As a professional business assistant, respond to this customer inquiry:
    
    Customer: "${customerMessage}"
    Detected Intent: ${intent}
    
    Available Services:
    ${availableServices.map(s => `- ${s.name}: ${s.description} (Starting at $${s.base_price})`).join('\n')}
    
    Guidelines:
    - Be helpful and professional
    - Keep responses concise for WhatsApp
    - Include relevant service information
    - Guide towards next steps (quote, booking, etc.)
    - Use emojis sparingly but effectively
  `;
  
  return prompt;
}

// Response templates based on intent
const responseTemplates = {
  pricing_inquiry: {
    template: "Hi {name}! 💰 I'd be happy to help with pricing for {service}. Our {service} starts at ${base_price}. Would you like a detailed quote tailored to your needs?",
    buttons: ["Get Quote", "View Packages", "Schedule Call"]
  },
  
  service_inquiry: {
    template: "Hello {name}! 👋 We offer several services:\n\n{service_list}\n\nWhich service interests you most?",
    buttons: ["Database Services", "Web Development", "Learn More"]
  },
  
  booking_request: {
    template: "Great! {name} 📅 I can help you schedule a consultation. What type of service are you interested in?\n\n{quick_services}",
    buttons: ["Database Consultation", "Development Project", "Other"]
  },
  
  support_request: {
    template: "Hi {name}! 🆘 I'm here to help. What specific question or issue can I assist you with today?",
    buttons: ["Technical Question", "Billing Inquiry", "Project Status"]
  }
};

// Dynamic response generation
function generateResponse(intent, customerData, services) {
  const template = responseTemplates[intent];
  let response = template.template;
  
  // Replace placeholders
  response = response.replace('{name}', customerData.name);
  
  if (intent === 'service_inquiry') {
    const serviceList = services
      .map(s => `• ${s.name} - Starting at $${s.base_price}`)
      .join('\n');
    response = response.replace('{service_list}', serviceList);
  }
  
  return {
    text: response,
    buttons: template.buttons
  };
}

// n8n Function Node - Calculate Dynamic Pricing
function calculatePricing(serviceId, requirements) {
  const baseService = $('Database Query').first().json;
  const pricingRules = $('Get Pricing Rules').all();
  
  let finalPrice = baseService.base_price;
  let appliedDiscounts = [];
  let priceBreakdown = [{
    item: baseService.name,
    price: baseService.base_price,
    type: 'base'
  }];
  
  // Apply quantity discounts
  if (requirements.quantity > 1) {
    const quantityRule = pricingRules.find(r => 
      r.json.condition_type === 'quantity' && 
      requirements.quantity >= r.json.condition_value.min_quantity
    );
    
    if (quantityRule) {
      const discount = finalPrice * (quantityRule.json.price_modifier / 100);
      finalPrice -= discount;
      appliedDiscounts.push({
        name: 'Quantity Discount',
        amount: discount,
        percentage: quantityRule.json.price_modifier
      });
    }
  }
  
  // Apply time-based pricing
  const currentHour = new Date().getHours();
  const rushHourRule = pricingRules.find(r => 
    r.json.condition_type === 'time_of_day' &&
    currentHour >= r.json.condition_value.start_hour &&
    currentHour <= r.json.condition_value.end_hour
  );
  
  if (rushHourRule) {
    const rushCharge = finalPrice * (rushHourRule.json.price_modifier / 100);
    finalPrice += rushCharge;
    priceBreakdown.push({
      item: 'Priority Service',
      price: rushCharge,
      type: 'addition'
    });
  }
  
  return {
    serviceId,
    basePrice: baseService.base_price,
    finalPrice: Math.round(finalPrice * 100) / 100,
    savings: appliedDiscounts.reduce((sum, d) => sum + d.amount, 0),
    breakdown: priceBreakdown,
    appliedDiscounts,
    requirements
  };
}

// Generate formatted quote for WhatsApp
function generateQuote(pricingData, customerInfo) {
  const { finalPrice, breakdown, appliedDiscounts, requirements } = pricingData;
  
  let quote = `📋 *Quote for ${customerInfo.name}*\n\n`;
  
  // Service breakdown
  breakdown.forEach(item => {
    const symbol = item.type === 'addition' ? '+' : '';
    quote += `${symbol}$${item.price} - ${item.item}\n`;
  });
  
  // Applied discounts
  if (appliedDiscounts.length > 0) {
    quote += '\n💰 *Discounts Applied:*\n';
    appliedDiscounts.forEach(discount => {
      quote += `-$${discount.amount.toFixed(2)} - ${discount.name}\n`;
    });
  }
  
  quote += `\n*Total: $${finalPrice}*\n\n`;
  quote += '✅ This quote is valid for 7 days\n';
  quote += '📞 Ready to proceed? Reply "BOOK" to schedule!';
  
  return quote;
}

// Store quote in database
const quoteData = {
  customer_phone: customerInfo.phone,
  customer_name: customerInfo.name,
  service_id: pricingData.serviceId,
  quote_amount: pricingData.finalPrice,
  quote_details: JSON.stringify(pricingData),
  valid_until: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000), // 7 days
  status: 'sent'
};

return quoteData;

// Google Calendar integration for booking
const calendarConfig = {
  calendarId: '[email protected]',
  timeZone: 'America/New_York',
  defaultDuration: 60, // minutes
  bufferTime: 15, // minutes between appointments
  workingHours: {
    start: '09:00',
    end: '17:00',
    days: [1, 2, 3, 4, 5] // Monday to Friday
  }
};

// Check availability function
async function checkAvailability(date, duration = 60) {
  const startTime = new Date(date);
  const endTime = new Date(startTime.getTime() + duration * 60000);
  
  // Query existing events
  const events = await getCalendarEvents(startTime, endTime);
  
  // Check for conflicts
  const hasConflict = events.some(event => {
    const eventStart = new Date(event.start.dateTime);
    const eventEnd = new Date(event.end.dateTime);
    return (startTime < eventEnd && endTime > eventStart);
  });
  
  return !hasConflict;
}

{
  "name": "WhatsApp Booking Flow",
  "nodes": [
    {
      "parameters": {
        "conditions": {
          "string": [
            {
              "value1": "={{$json.text.toLowerCase()}}",
              "operation": "contains",
              "value2": "book"
            }
          ]
        }
      },
      "name": "Check Booking Intent",
      "type": "n8n-nodes-base.if"
    },
    {
      "parameters": {
        "jsCode": "// Extract preferred time from message\nconst message = $input.first().json.text;\nconst timePatterns = [\n  /tomorrow at (\\d{1,2}(?::\\d{2})?\\s*(?:am|pm))/i,\n  /(\\d{1,2})\\/(\\d{1,2}).*?(\\d{1,2}(?::\\d{2})?\\s*(?:am|pm))/i,\n  /(monday|tuesday|wednesday|thursday|friday|saturday|sunday).*?(\\d{1,2}(?::\\d{2})?\\s*(?:am|pm))/i\n];\n\nlet extractedTime = null;\nfor (const pattern of timePatterns) {\n  const match = message.match(pattern);\n  if (match) {\n    extractedTime = match[0];\n    break;\n  }\n}\n\nreturn {\n  ...item,\n  extractedTime,\n  needsTimeConfirmation: !extractedTime\n};"
      },
      "name": "Extract Time Preference",
      "type": "n8n-nodes-base.code"
    },
    {
      "parameters": {
        "operation": "create",
        "calendarId": "={{ $json.calendarId }}",
        "start": "={{ $json.startTime }}",
        "end": "={{ $json.endTime }}",
        "summary": "Consultation - {{ $json.customerName }}",
        "description": "WhatsApp booking for {{ $json.serviceType }}\nCustomer: {{ $json.customerName }}\nPhone: {{ $json.customerPhone }}"
      },
      "name": "Create Calendar Event",
      "type": "n8n-nodes-base.googleCalendar"
    }
  ]
}

// Send booking confirmation
function createBookingConfirmation(appointmentData) {
  const { customerName, appointmentTime, serviceType, consultantName } = appointmentData;
  
  const confirmation = `
✅ *Booking Confirmed!*

👤 *Customer:* ${customerName}
🔧 *Service:* ${serviceType}
📅 *Date & Time:* ${formatDateTime(appointmentTime)}
👨‍💼 *Consultant:* ${consultantName}

📍 *Meeting Details:*
• Video call link will be sent 10 minutes before
• Please have your requirements ready
• Bring any relevant documentation

📞 *Need to reschedule?* Reply "RESCHEDULE"
❌ *Need to cancel?* Reply "CANCEL"

Looking forward to helping you! 🚀
  `.trim();
  
  return confirmation;
}

// Reminder system
function scheduleReminders(appointmentData) {
  const reminderTimes = [
    { hours: 24, message: "📅 Reminder: You have a consultation scheduled for tomorrow at {time}" },
    { hours: 2, message: "🔔 Your consultation starts in 2 hours. Meeting link: {link}" },
    { minutes: 10, message: "🚀 Your consultation starts in 10 minutes! Join here: {link}" }
  ];
  
  reminderTimes.forEach(reminder => {
    scheduleMessage(appointmentData.customerPhone, reminder.message, reminder);
  });
}

// Multi-step customer journey
const customerJourney = {
  initial_contact: {
    immediate: "Welcome message with service overview",
    delay_1hour: "Follow-up with detailed service catalog",
    actions: ["Send welcome packet", "Tag as new lead"]
  },
  
  quote_provided: {
    delay_1day: "Check if they have questions about the quote",
    delay_3days: "Offer consultation call",
    delay_1week: "Final follow-up with limited-time discount",
    actions: ["Track quote views", "Note interest level"]
  },
  
  consultation_booked: {
    immediate: "Booking confirmation and preparation guide",
    delay_1day: "Send reminder with meeting prep checklist",
    delay_2hours: "Final reminder with meeting link",
    actions: ["Add to calendar", "Send prep materials"]
  },
  
  post_consultation: {
    immediate: "Thank you message and next steps",
    delay_1day: "Follow-up with proposal or additional information",
    delay_1week: "Check on decision timeline",
    actions: ["Send proposal", "Schedule follow-up"]
  }
};

// Journey automation workflow
function executeJourneyStep(customerPhone, journeyStage, stepKey) {
  const step = customerJourney[journeyStage][stepKey];
  
  if (step.startsWith('delay_')) {
    // Schedule delayed message
    const delay = parseDelay(stepKey);
    scheduleDelayedMessage(customerPhone, step, delay);
  } else {
    // Send immediate message
    sendWhatsAppMessage(customerPhone, step);
  }
  
  // Execute associated actions
  if (customerJourney[journeyStage].actions) {
    customerJourney[journeyStage].actions.forEach(action => {
      executeAction(action, customerPhone);
    });
  }
}

// State machine for conversation management
class ConversationManager {
  constructor() {
    this.states = {
      INITIAL: 'initial',
      SERVICE_INQUIRY: 'service_inquiry',
      PRICING_DISCUSSION: 'pricing_discussion',
      BOOKING_PROCESS: 'booking_process',
      QUOTE_REVIEW: 'quote_review',
      CONSULTATION_SCHEDULED: 'consultation_scheduled'
    };
  }
  
  processMessage(customerPhone, message, currentState) {
    switch (currentState) {
      case this.states.INITIAL:
        return this.handleInitialContact(message);
        
      case this.states.SERVICE_INQUIRY:
        return this.handleServiceInquiry(message);
        
      case this.states.PRICING_DISCUSSION:
        return this.handlePricingDiscussion(message);
        
      case this.states.BOOKING_PROCESS:
        return this.handleBookingProcess(message);
        
      default:
        return this.handleGeneral(message);
    }
  }
  
  handleServiceInquiry(message) {
    const intent = this.detectIntent(message);
    
    if (intent === 'specific_service') {
      return {
        response: this.getServiceDetails(message),
        nextState: this.states.PRICING_DISCUSSION,
        actions: ['log_service_interest', 'prepare_quote']
      };
    }
    
    return {
      response: this.getServiceOverview(),
      nextState: this.states.SERVICE_INQUIRY,
      actions: ['send_service_catalog']
    };
  }
}

-- Customer interaction analytics
CREATE VIEW customer_analytics AS
SELECT 
    phone_number,
    customer_name,
    COUNT(*) as total_interactions,
    COUNT(DISTINCT DATE(created_at)) as active_days,
    ARRAY_AGG(DISTINCT intent) as inquired_about,
    MIN(created_at) as first_contact,
    MAX(created_at) as last_contact,
    CASE 
        WHEN MAX(created_at) > NOW() - INTERVAL '7 days' THEN 'Active'
        WHEN MAX(created_at) > NOW() - INTERVAL '30 days' THEN 'Recent'
        ELSE 'Dormant'
    END as customer_status
FROM customer_interactions
GROUP BY phone_number, customer_name;

-- Service popularity analytics
CREATE VIEW service_analytics AS
SELECT 
    s.name as service_name,
    s.category,
    COUNT(ci.id) as inquiry_count,
    COUNT(DISTINCT ci.phone_number) as unique_customers,
    AVG(s.base_price) as avg_price,
    COUNT(CASE WHEN ci.intent = 'pricing_inquiry' THEN 1 END) as pricing_requests
FROM services s
LEFT JOIN customer_interactions ci ON ci.message_text ILIKE '%' || s.name || '%'
GROUP BY s.id, s.name, s.category;

// Track customer journey conversion rates
const conversionMetrics = {
  inquiry_to_quote: {
    numerator: "COUNT(DISTINCT CASE WHEN stage = 'quote_sent' THEN customer_phone END)",
    denominator: "COUNT(DISTINCT CASE WHEN stage = 'initial_inquiry' THEN customer_phone END)"
  },
  
  quote_to_booking: {
    numerator: "COUNT(DISTINCT CASE WHEN stage = 'consultation_booked' THEN customer_phone END)",
    denominator: "COUNT(DISTINCT CASE WHEN stage = 'quote_sent' THEN customer_phone END)"
  },
  
  booking_to_close: {
    numerator: "COUNT(DISTINCT CASE WHEN stage = 'project_signed' THEN customer_phone END)",
    denominator: "COUNT(DISTINCT CASE WHEN stage = 'consultation_booked' THEN customer_phone END)"
  }
};

// Generate daily conversion report
function generateConversionReport() {
  const report = `
📊 *Daily WhatsApp Conversion Report*
Date: ${new Date().toLocaleDateString()}

🔢 *Key Metrics:*
• Messages Received: ${metrics.total_messages}
• Unique Customers: ${metrics.unique_customers}
• Quotes Sent: ${metrics.quotes_sent}
• Bookings Made: ${metrics.bookings_made}

📈 *Conversion Rates:*
• Inquiry → Quote: ${metrics.inquiry_to_quote}%
• Quote → Booking: ${metrics.quote_to_booking}%
• Booking → Close: ${metrics.booking_to_close}%

🏆 *Top Services Inquired:*
${metrics.top_services.map(s => `• ${s.name}: ${s.inquiries} inquiries`).join('\n')}

💰 *Revenue Pipeline:*
• Quotes Outstanding: $${metrics.outstanding_quotes}
• Potential Monthly Revenue: $${metrics.potential_revenue}
  `;
  
  return report;
}

// Agent routing system
const agentRouting = {
  database_expert: {
    specialties: ['database', 'postgresql', 'mysql', 'optimization'],
    availability: 'Mon-Fri 9AM-6PM EST',
    phone: '+1234567890'
  },
  
  web_developer: {
    specialties: ['website', 'web development', 'e-commerce', 'api'],
    availability: 'Mon-Fri 10AM-7PM EST',
    phone: '+1234567891'
  },
  
  project_manager: {
    specialties: ['consultation', 'project planning', 'quotes'],
    availability: 'Mon-Fri 8AM-8PM EST',
    phone: '+1234567892'
  }
};

function routeToAgent(inquiry, customerInfo) {
  const bestAgent = findBestAgent(inquiry.intent, inquiry.text);
  
  if (bestAgent.isAvailable()) {
    return {
      action: 'transfer_to_agent',
      agent: bestAgent,
      message: `Connecting you with ${bestAgent.name}, our ${bestAgent.title}. They'll be with you shortly! 👨‍💼`
    };
  } else {
    return {
      action: 'schedule_callback',
      message: `Our ${bestAgent.title} is currently unavailable. When would be a good time for them to call you back?`,
      agent: bestAgent
    };
  }
}

// Salesforce/HubSpot integration
async function syncTosCRM(customerData, interactionData) {
  const contact = {
    firstName: customerData.name.split(' ')[0],
    lastName: customerData.name.split(' ').slice(1).join(' '),
    phone: customerData.phone,
    source: 'WhatsApp Business',
    lastContactDate: new Date(),
    leadStatus: determineLeadStatus(interactionData),
    services_interested: interactionData.services_mentioned,
    interaction_history: interactionData.messages
  };
  
  // Check if contact exists
  const existingContact = await crmApi.findContact(contact.phone);
  
  if (existingContact) {
    // Update existing contact
    await crmApi.updateContact(existingContact.id, {
      lastContactDate: contact.lastContactDate,
      leadStatus: contact.leadStatus,
      interaction_history: [...existingContact.interaction_history, ...contact.interaction_history]
    });
  } else {
    // Create new contact
    await crmApi.createContact(contact);
  }
  
  // Create activity record
  await crmApi.createActivity({
    contactId: existingContact?.id || newContact.id,
    type: 'WhatsApp Message',
    subject: `WhatsApp inquiry about ${interactionData.primary_intent}`,
    description: interactionData.summary,
    date: new Date()
  });
}

// Language detection and response
const languageSupport = {
  detect: (message) => {
    // Use Google Translate API or similar
    return detectLanguage(message);
  },
  
  translate: async (text, targetLanguage) => {
    const translated = await translateText(text, targetLanguage);
    return translated;
  },
  
  getLocalizedResponses: (intent, language) => {
    const responses = {
      en: {
        greeting: "Hello! How can I help you today?",
        pricing: "I'd be happy to provide pricing information.",
        booking: "Let's schedule your consultation!"
      },
      es: {
        greeting: "¡Hola! ¿Cómo puedo ayudarte hoy?",
        pricing: "Estaré encantado de proporcionarte información de precios.",
        booking: "¡Programemos tu consulta!"
      },
      fr: {
        greeting: "Bonjour! Comment puis-je vous aider aujourd'hui?",
        pricing: "Je serais ravi de vous fournir des informations sur les prix.",
        booking: "Planifions votre consultation!"
      }
    };
    
    return responses[language] || responses.en;
  }
};