Bot de WhatsApp con IA en menos de una semana: guía completa

// app/api/whatsapp/webhook/route.ts
import { NextRequest, NextResponse } from 'next/server'
import crypto from 'crypto'
import { processIncomingMessage } from '@/lib/whatsapp/processor'

// Meta verifica el webhook con un GET al registrarlo
export async function GET(req: NextRequest) {
  const { searchParams } = new URL(req.url)
  const mode      = searchParams.get('hub.mode')
  const token     = searchParams.get('hub.verify_token')
  const challenge = searchParams.get('hub.challenge')

  if (mode === 'subscribe' && token === process.env.WHATSAPP_VERIFY_TOKEN) {
    return new NextResponse(challenge, { status: 200 })
  }
  return new NextResponse('Forbidden', { status: 403 })
}

// Meta envía los mensajes entrantes por POST
export async function POST(req: NextRequest) {
  // 1. Verificar firma HMAC para asegurar que viene de Meta
  const rawBody  = await req.text()
  const sigHeader = req.headers.get('x-hub-signature-256') ?? ''
  const expected = 'sha256=' + crypto
    .createHmac('sha256', process.env.WHATSAPP_APP_SECRET!)
    .update(rawBody)
    .digest('hex')

  if (sigHeader !== expected) {
    return new NextResponse('Unauthorized', { status: 401 })
  }

  // 2. Parsear el payload
  const body = JSON.parse(rawBody)
  const entry   = body.entry?.[0]
  const changes = entry?.changes?.[0]
  const value   = changes?.value

  // Ignorar notificaciones de estado (delivered, read, etc.)
  if (!value?.messages?.length) {
    return new NextResponse('OK', { status: 200 })
  }

  const message = value.messages[0]
  const phone   = message.from          // número del usuario
  const msgType = message.type          // 'text' | 'image' | 'audio' | ...

  // 3. Solo procesamos texto; para otros tipos enviamos instrucción
  if (msgType !== 'text') {
    await sendWhatsAppMessage(phone,
      'Por favor escríbeme en texto para poder ayudarte 😊'
    )
    return new NextResponse('OK', { status: 200 })
  }

  const userText = message.text.body

  // 4. Procesar mensaje con IA y responder (async, no bloqueamos a Meta)
  processIncomingMessage({ phone, userText }).catch(console.error)

  // Meta requiere 200 en menos de 5 s
  return new NextResponse('OK', { status: 200 })
}

// Función helper para enviar mensajes
export async function sendWhatsAppMessage(to: string, text: string) {
  const url = `https://graph.facebook.com/v20.0/${process.env.WHATSAPP_PHONE_NUMBER_ID}/messages`
  await fetch(url, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      Authorization: `Bearer ${process.env.WHATSAPP_TOKEN}`,
    },
    body: JSON.stringify({
      messaging_product: 'whatsapp',
      to,
      type: 'text',
      text: { body: text },
    }),
  })
}

-- Tabla de sesiones conversacionales
CREATE TABLE bot_sessions (
  id         UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  phone      TEXT NOT NULL UNIQUE,   -- +573001234567
  history    JSONB NOT NULL DEFAULT '[]',
  -- [{ role: 'user'|'assistant', content: '...' }]
  created_at TIMESTAMPTZ DEFAULT now(),
  updated_at TIMESTAMPTZ DEFAULT now()
);

CREATE INDEX idx_bot_sessions_phone ON bot_sessions(phone);

-- Trigger para actualizar updated_at automáticamente
CREATE OR REPLACE FUNCTION update_updated_at()
RETURNS TRIGGER AS $$
BEGIN NEW.updated_at = now(); RETURN NEW; END;
$$ LANGUAGE plpgsql;

CREATE TRIGGER bot_sessions_updated_at
  BEFORE UPDATE ON bot_sessions
  FOR EACH ROW EXECUTE FUNCTION update_updated_at();

// lib/whatsapp/session.ts
import { db } from '@/lib/db'  // instancia de postgres.js o Drizzle

const MAX_HISTORY = 20
const SESSION_TTL_HOURS = 24

export async function getOrCreateSession(phone: string) {
  const row = await db.query.botSessions.findFirst({
    where: (s, { eq }) => eq(s.phone, phone),
  })

  if (!row) {
    return db.insert(botSessions).values({ phone, history: [] }).returning()
  }

  // Resetear sesión expirada
  const hoursInactive = (Date.now() - row.updatedAt.getTime()) / 36e5
  if (hoursInactive > SESSION_TTL_HOURS) {
    await db.update(botSessions)
      .set({ history: [] })
      .where(eq(botSessions.phone, phone))
    return { ...row, history: [] }
  }

  return row
}

export async function appendToHistory(
  phone: string,
  newTurns: { role: 'user' | 'assistant'; content: string }[]
) {
  const session = await getOrCreateSession(phone)
  const updated = [...session.history, ...newTurns].slice(-MAX_HISTORY)
  await db.update(botSessions)
    .set({ history: updated })
    .where(eq(botSessions.phone, phone))
}

// lib/whatsapp/prompt.ts
export function buildSystemPrompt(today: Date): string {
  const dia = today.toLocaleDateString('es-CO', {
    weekday: 'long', year: 'numeric', month: 'long', day: 'numeric'
  })

  return `Eres Sofia, asistente virtual de Clínica Estética Aurora en Bogotá.
Hoy es ${dia}. Responde siempre en español colombiano, de forma cálida y profesional.
Usa emojis con moderación.

## SERVICIOS Y PRECIOS
- Limpieza facial profunda: $85 000 COP — 60 min
- Tratamiento anti-acné: $120 000 COP — 75 min
- Hidratación intensiva: $95 000 COP — 60 min
- Diseño de cejas: $45 000 COP — 30 min

## HORARIOS
Lunes a viernes: 8:00 am – 7:00 pm
Sábado: 8:00 am – 3:00 pm
Domingos y festivos: CERRADO

## FLUJO DE AGENDAMIENTO
1. Pregunta qué servicio desea.
2. Pregunta la fecha y hora preferida. Interpreta expresiones como
   "el próximo viernes en la tarde" o "mañana a las 3".
3. Confirma nombre completo del paciente.
4. Confirma el turno con todos los datos y un resumen.
5. Al confirmar, responde EXACTAMENTE en este formato JSON
   (y nada más después de él):
   BOOKING:{"servicio":"...","fecha":"YYYY-MM-DD","hora":"HH:mm","nombre":"..."}

## REGLAS
- Nunca inventes disponibilidad; di que un agente confirmará en breve.
- Si preguntan algo fuera de tu alcance, da el número directo: 601-234-5678.
- No discutas temas no relacionados con la clínica.`
}

// lib/whatsapp/processor.ts
import { getOrCreateSession, appendToHistory } from './session'
import { buildSystemPrompt } from './prompt'
import { sendWhatsAppMessage } from '@/app/api/whatsapp/webhook/route'

export async function processIncomingMessage({
  phone, userText,
}: { phone: string; userText: string }) {
  const session   = await getOrCreateSession(phone)
  const newUserTurn = { role: 'user' as const, content: userText }

  // Llamada a OpenRouter (compatible con OpenAI SDK)
  const response = await fetch('https://openrouter.ai/api/v1/chat/completions', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      Authorization: `Bearer ${process.env.OPENROUTER_API_KEY}`,
      'HTTP-Referer': 'https://edwsystem.com',
    },
    body: JSON.stringify({
      model: 'meta-llama/llama-3.1-70b-instruct',
      messages: [
        { role: 'system', content: buildSystemPrompt(new Date()) },
        ...session.history,
        newUserTurn,
      ],
      max_tokens: 400,
      temperature: 0.4,
    }),
  })

  const data = await response.json()
  const assistantText: string = data.choices[0].message.content

  // Persistir historial
  await appendToHistory(phone, [
    newUserTurn,
    { role: 'assistant', content: assistantText },
  ])

  // Detectar si el bot generó un booking
  const bookingMatch = assistantText.match(/BOOKING:({.*})/)
  if (bookingMatch) {
    const booking = JSON.parse(bookingMatch[1])
    await createAppointment(booking)   // lógica de negocio propia
    // Enviar solo el texto antes del JSON al usuario
    const displayText = assistantText.replace(/BOOKING:{.*}/, '').trim()
    await sendWhatsAppMessage(phone, displayText)
    return
  }

  await sendWhatsAppMessage(phone, assistantText)
}