elevenlabs-webhook-nodejs 1.0.0

package/src/modules/webhooks/elevenlabs-tool.service.ts

@@ -0,0 +1,491 @@
+import mongoose from 'mongoose';
+import Tenant from '../tenants/tenant.model';
+import Agent from '../agents/agent.model';
+import Appointment from '../whatsapp/appointment.model';
+import AppointmentValidationBatch from '../appointment-validation/appointment-validation.model';
+import WhatsAppChat from '../whatsapp/whatsapp-chat.model';
+import WhatsAppSession from '../whatsapp/whatsapp-session.model';
+import WhatsAppContactProfile from '../whatsapp/whatsapp-contact-profile.model';
+import OperatorRequest from '../whatsapp/operator-request.model';
+import googleCalendarService from '../../services/google-calendar.service';
+import netgsmService from '../../services/netgsm.service';
+import { recordValidationResult } from '../appointment-validation/appointment-validation.service';
+import config from '../../config';
+import logger from '../../utils/logger';
+
+export interface ToolContext {
+  agentId: string;        // ElevenLabs agent ID string (may be empty)
+  conversationId: string; // ElevenLabs conversation ID
+  patientPhone: string;   // E.164 format
+  patientName: string;
+}
+
+interface ResolvedTenant {
+  tenantId: string;
+  tenant: InstanceType<typeof Tenant>;
+}
+
+/**
+ * Resolve tenant from agent_id or conversation_id.
+ * Tries agent_id first, then falls back to looking up conversation_id in validation batches.
+ */
+async function resolveTenant(ctx: ToolContext): Promise<ResolvedTenant> {
+  // Try agent_id first
+  if (ctx.agentId) {
+    const agent = await Agent.findOne({ elevenlabs_agent_id: ctx.agentId, is_active: true }).lean();
+    if (agent) {
+      const tenant = await Tenant.findById(agent.tenant_id);
+      if (tenant) return { tenantId: tenant._id.toString(), tenant };
+    }
+  }
+
+  // Fallback: resolve from conversation_id via validation batch
+  if (ctx.conversationId) {
+    const batch = await AppointmentValidationBatch.findOne(
+      { 'entries.conversation_id': ctx.conversationId },
+      { tenant_id: 1 },
+    ).lean();
+    if (batch) {
+      const tenant = await Tenant.findById(batch.tenant_id);
+      if (tenant) return { tenantId: tenant._id.toString(), tenant };
+    }
+  }
+
+  throw new Error('Could not resolve tenant from agent_id or conversation_id');
+}
+
+function getCalendarSettings(tenant: InstanceType<typeof Tenant>) {
+  const gcal = tenant.settings?.whatsapp_agent?.google_calendar;
+  if (!gcal?.connected || !gcal?.calendar_id) {
+    throw new Error('Google Calendar not configured');
+  }
+  return gcal;
+}
+
+// ─── Tool Handlers ──────────────────────────────────────────
+
+async function checkAvailability(
+  ctx: ToolContext,
+  parameters: Record<string, unknown>,
+): Promise<string> {
+  const { tenant } = await resolveTenant(ctx);
+  const gcal = getCalendarSettings(tenant);
+
+  const date = parameters.date as string;
+  if (!date || !/^\d{4}-\d{2}-\d{2}$/.test(date)) {
+    return JSON.stringify({ error: 'Invalid date format. Use YYYY-MM-DD' });
+  }
+
+  const today = new Date().toISOString().split('T')[0];
+  if (date < today) {
+    return JSON.stringify({ error: `Geçmiş tarih için randevu oluşturulamaz. Bugünün tarihi: ${today}` });
+  }
+
+  const result = await googleCalendarService.checkAvailability(
+    tenant._id.toString(), date,
+  );
+
+  if (result.slots.length === 0) {
+    return JSON.stringify({
+      date,
+      available_slots: [],
+      message: result.message || 'Bu tarihte müsait randevu yok',
+    });
+  }
+
+  return JSON.stringify({
+    date,
+    available_slots: result.slots,
+    appointment_duration_minutes: gcal.appointment_duration_minutes,
+  });
+}
+
+async function reserveSlot(
+  ctx: ToolContext,
+  parameters: Record<string, unknown>,
+): Promise<string> {
+  const { tenantId, tenant } = await resolveTenant(ctx);
+  const gcal = getCalendarSettings(tenant);
+
+  const patientName = (parameters.patient_name as string) || ctx.patientName || 'Bilinmeyen Hasta';
+  const patientPhone = ctx.patientPhone;
+  const isoStart = parameters.iso_start as string;
+  const isoEnd = parameters.iso_end as string;
+  const notes = (parameters.notes as string) || '';
+
+  if (!isoStart || !isoEnd) {
+    return JSON.stringify({ error: 'iso_start and iso_end are required' });
+  }
+
+  const appointmentId = new mongoose.Types.ObjectId();
+
+  const result = await googleCalendarService.reserveSlot(
+    tenantId,
+    { iso_start: isoStart, iso_end: isoEnd, patient_name: patientName, patient_phone: patientPhone, notes, appointment_id: appointmentId.toString() },
+  );
+
+  // Persist appointment (no chat_id/session_id for voice calls)
+  Appointment.create({
+    _id: appointmentId,
+    tenant_id: new mongoose.Types.ObjectId(tenantId),
+    google_event_id: result.event_id,
+    patient_name: patientName,
+    patient_phone: patientPhone,
+    start_time: new Date(result.start),
+    end_time: new Date(result.end),
+    duration_minutes: gcal.appointment_duration_minutes,
+    notes,
+    source: 'voice_call',
+    conversation_id: ctx.conversationId,
+    status: 'scheduled',
+  }).catch(err => logger.error('Failed to persist voice appointment', { error: (err as Error).message }));
+
+  // SMS notification (fire-and-forget)
+  const smsSettings = tenant.settings?.whatsapp_agent;
+  if (smsSettings?.sms_notification_enabled && smsSettings.sms_notification_phones?.length) {
+    const startDt = new Date(result.start);
+    const tz = gcal.timezone || 'Europe/Istanbul';
+    netgsmService.notifyAppointmentCreated({
+      phones: smsSettings.sms_notification_phones,
+      patientName,
+      patientPhone,
+      date: startDt.toLocaleDateString('tr-TR', { day: 'numeric', month: 'long', year: 'numeric', weekday: 'long', timeZone: tz }),
+      time: startDt.toLocaleTimeString('tr-TR', { hour: '2-digit', minute: '2-digit', timeZone: tz }),
+      notes,
+      detailUrl: `${config.google.frontendUrl}/appointments/${appointmentId}`,
+    }).catch(err => logger.error('SMS notification failed (voice create)', { error: (err as Error).message }));
+  }
+
+  return JSON.stringify({
+    reserved: true,
+    event_id: result.event_id,
+    start: result.start,
+    end: result.end,
+    patient_name: patientName,
+  });
+}
+
+async function listReservations(
+  ctx: ToolContext,
+  _parameters: Record<string, unknown>,
+): Promise<string> {
+  const { tenantId, tenant } = await resolveTenant(ctx);
+  getCalendarSettings(tenant); // validates calendar is connected
+
+  const patientPhone = ctx.patientPhone;
+  if (!patientPhone) {
+    return JSON.stringify({ error: 'Patient phone not available' });
+  }
+
+  const reservations = await googleCalendarService.listReservations(
+    tenantId, patientPhone,
+  );
+
+  return JSON.stringify({
+    reservations,
+    count: reservations.length,
+  });
+}
+
+async function cancelReservation(
+  ctx: ToolContext,
+  parameters: Record<string, unknown>,
+): Promise<string> {
+  const { tenantId, tenant } = await resolveTenant(ctx);
+  const gcal = getCalendarSettings(tenant);
+
+  const patientPhone = ctx.patientPhone;
+  const eventId = parameters.event_id as string;
+
+  if (!eventId) {
+    return JSON.stringify({ error: 'event_id is required' });
+  }
+
+  const cancelled = await googleCalendarService.cancelReservation(
+    tenantId, eventId, patientPhone,
+  );
+
+  if (cancelled) {
+    const appt = await Appointment.findOneAndUpdate(
+      { google_event_id: eventId, tenant_id: tenantId },
+      { status: 'cancelled', cancelled_at: new Date() },
+    ).lean();
+
+    // SMS notification (fire-and-forget)
+    const smsSettings = tenant.settings?.whatsapp_agent;
+    if (appt && smsSettings?.sms_notification_enabled && smsSettings.sms_notification_phones?.length) {
+      const tz = gcal.timezone || 'Europe/Istanbul';
+      netgsmService.notifyAppointmentCancelled({
+        phones: smsSettings.sms_notification_phones,
+        patientName: appt.patient_name,
+        patientPhone,
+        date: appt.start_time.toLocaleDateString('tr-TR', { day: 'numeric', month: 'long', weekday: 'long', timeZone: tz }),
+        time: appt.start_time.toLocaleTimeString('tr-TR', { hour: '2-digit', minute: '2-digit', timeZone: tz }),
+      }).catch(err => logger.error('SMS notification failed (voice cancel)', { error: (err as Error).message }));
+    }
+  }
+
+  return JSON.stringify({ cancelled, event_id: eventId });
+}
+
+async function rescheduleReservation(
+  ctx: ToolContext,
+  parameters: Record<string, unknown>,
+): Promise<string> {
+  const { tenantId, tenant } = await resolveTenant(ctx);
+  const gcal = getCalendarSettings(tenant);
+
+  const patientPhone = ctx.patientPhone;
+  const patientName = (parameters.patient_name as string) || ctx.patientName || 'Bilinmeyen Hasta';
+  const oldEventId = parameters.old_event_id as string;
+  const newIsoStart = parameters.new_iso_start as string;
+  const newIsoEnd = parameters.new_iso_end as string;
+  const notes = (parameters.notes as string) || '';
+
+  if (!oldEventId) {
+    return JSON.stringify({ error: 'old_event_id is required' });
+  }
+  if (!newIsoStart || !newIsoEnd) {
+    return JSON.stringify({ error: 'new_iso_start and new_iso_end are required' });
+  }
+
+  // Fetch old appointment info for SMS before cancelling
+  const oldAppt = await Appointment.findOne(
+    { google_event_id: oldEventId, tenant_id: tenantId },
+  ).lean();
+
+  // Step 1: Cancel old reservation
+  try {
+    await googleCalendarService.cancelReservation(
+      tenantId, oldEventId, patientPhone,
+    );
+
+    Appointment.updateOne(
+      { google_event_id: oldEventId, tenant_id: tenantId },
+      { status: 'cancelled', cancelled_at: new Date() },
+    ).catch(err => logger.error('Failed to update appointment status', { error: (err as Error).message }));
+  } catch (err) {
+    return JSON.stringify({ error: `Eski randevu iptal edilemedi: ${(err as Error).message}` });
+  }
+
+  // Step 2: Create new reservation
+  const appointmentId = new mongoose.Types.ObjectId();
+
+  try {
+    const result = await googleCalendarService.reserveSlot(
+      tenantId,
+      { iso_start: newIsoStart, iso_end: newIsoEnd, patient_name: patientName, patient_phone: patientPhone, notes, appointment_id: appointmentId.toString() },
+    );
+
+    Appointment.create({
+      _id: appointmentId,
+      tenant_id: new mongoose.Types.ObjectId(tenantId),
+      google_event_id: result.event_id,
+      patient_name: patientName,
+      patient_phone: patientPhone,
+      start_time: new Date(result.start),
+      end_time: new Date(result.end),
+      duration_minutes: gcal.appointment_duration_minutes,
+      notes,
+      source: 'voice_call',
+      conversation_id: ctx.conversationId,
+      status: 'scheduled',
+    }).catch(err => logger.error('Failed to persist rescheduled voice appointment', { error: (err as Error).message }));
+
+    // SMS notification (fire-and-forget)
+    const smsSettings = tenant.settings?.whatsapp_agent;
+    if (smsSettings?.sms_notification_enabled && smsSettings.sms_notification_phones?.length) {
+      const tz = gcal.timezone || 'Europe/Istanbul';
+      const newStartDt = new Date(result.start);
+      netgsmService.notifyAppointmentRescheduled({
+        phones: smsSettings.sms_notification_phones,
+        patientName,
+        patientPhone,
+        oldDate: oldAppt
+          ? oldAppt.start_time.toLocaleDateString('tr-TR', { day: 'numeric', month: 'long', weekday: 'long', timeZone: tz })
+          : 'Bilinmiyor',
+        oldTime: oldAppt
+          ? oldAppt.start_time.toLocaleTimeString('tr-TR', { hour: '2-digit', minute: '2-digit', timeZone: tz })
+          : '',
+        newDate: newStartDt.toLocaleDateString('tr-TR', { day: 'numeric', month: 'long', weekday: 'long', timeZone: tz }),
+        newTime: newStartDt.toLocaleTimeString('tr-TR', { hour: '2-digit', minute: '2-digit', timeZone: tz }),
+        detailUrl: `${config.google.frontendUrl}/appointments/${appointmentId}`,
+      }).catch(err => logger.error('SMS notification failed (voice reschedule)', { error: (err as Error).message }));
+    }
+
+    return JSON.stringify({
+      rescheduled: true,
+      old_event_id: oldEventId,
+      new_event_id: result.event_id,
+      start: result.start,
+      end: result.end,
+      patient_name: patientName,
+    });
+  } catch (err) {
+    return JSON.stringify({ error: `Eski randevu iptal edildi ancak yeni randevu oluşturulamadı: ${(err as Error).message}. Lütfen tekrar deneyin.` });
+  }
+}
+
+async function checkPatientHistory(
+  ctx: ToolContext,
+  _parameters: Record<string, unknown>,
+): Promise<string> {
+  const { tenantId } = await resolveTenant(ctx);
+
+  const patientPhone = ctx.patientPhone;
+  if (!patientPhone) {
+    return JSON.stringify({ error: 'Patient phone not available' });
+  }
+
+  // Find all chats for this patient under this tenant
+  const patientChats = await WhatsAppChat.find(
+    { tenant_id: tenantId, contact_phone: patientPhone },
+    { _id: 1 },
+  ).lean();
+  const chatIds = patientChats.map(c => c._id);
+
+  const [contactProfile, appointments, operatorRequests, sessions] = await Promise.all([
+    WhatsAppContactProfile.findOne(
+      { tenant_id: tenantId, phone: patientPhone },
+      { display_name: 1, notes: 1, tags: 1, ai_summary: 1, preferred_language: 1, metadata: 1, first_seen_at: 1, last_seen_at: 1, total_sessions: 1, total_messages: 1 },
+    ).lean(),
+
+    Appointment.find(
+      { tenant_id: tenantId, patient_phone: patientPhone },
+      { start_time: 1, end_time: 1, duration_minutes: 1, status: 1, notes: 1, cancelled_at: 1, createdAt: 1 },
+    ).sort({ start_time: -1 }).limit(10).lean(),
+
+    chatIds.length > 0
+      ? OperatorRequest.find(
+          { tenant_id: tenantId, chat_id: { $in: chatIds } },
+          { ref_code: 1, request_type: 1, status: 1, operator_response: 1, forwarded_at: 1, responded_at: 1 },
+        ).sort({ createdAt: -1 }).limit(10).lean()
+      : [],
+
+    chatIds.length > 0
+      ? WhatsAppSession.find(
+          { tenant_id: tenantId, chat_id: { $in: chatIds } },
+          { status: 1, started_at: 1, resolved_at: 1, resolved_by: 1, message_count: 1 },
+        ).sort({ started_at: -1 }).limit(10).lean()
+      : [],
+  ]);
+
+  const now = new Date();
+
+  return JSON.stringify({
+    patient_phone: patientPhone,
+    contact_profile: contactProfile ? {
+      display_name: contactProfile.display_name,
+      notes: contactProfile.notes || undefined,
+      tags: contactProfile.tags.length > 0 ? contactProfile.tags : undefined,
+      ai_summary: contactProfile.ai_summary || undefined,
+      preferred_language: contactProfile.preferred_language || undefined,
+      metadata: contactProfile.metadata && Object.keys(contactProfile.metadata).length > 0 ? contactProfile.metadata : undefined,
+      first_seen: contactProfile.first_seen_at?.toISOString().split('T')[0],
+      last_seen: contactProfile.last_seen_at?.toISOString().split('T')[0],
+      total_sessions: contactProfile.total_sessions,
+      total_messages: contactProfile.total_messages,
+    } : null,
+    appointments: appointments.map(a => ({
+      date: a.start_time.toISOString().split('T')[0],
+      time: a.start_time.toISOString().split('T')[1].substring(0, 5),
+      duration_minutes: a.duration_minutes,
+      status: a.status,
+      notes: a.notes || undefined,
+      is_upcoming: a.start_time > now && a.status === 'scheduled',
+    })),
+    operator_requests: operatorRequests.map(r => ({
+      ref_code: r.ref_code,
+      type: r.request_type,
+      status: r.status,
+      response: r.operator_response || undefined,
+      date: r.forwarded_at.toISOString().split('T')[0],
+    })),
+    total_sessions: sessions.length,
+    total_appointments: appointments.length,
+    total_cancelled: appointments.filter(a => a.status === 'cancelled').length,
+    upcoming_appointments: appointments.filter(a => a.start_time > now && a.status === 'scheduled').length,
+  });
+}
+
+async function confirmAppointmentValidation(
+  ctx: ToolContext,
+  parameters: Record<string, unknown>,
+): Promise<string> {
+  const { tenantId } = await resolveTenant(ctx);
+
+  const result = parameters.result as string;
+  if (!result || !['confirmed', 'cancelled', 'reschedule'].includes(result)) {
+    return JSON.stringify({ error: 'result must be one of: confirmed, cancelled, reschedule' });
+  }
+
+  const rescheduleRequest = (parameters.reschedule_request as string) || null;
+  const patientMessage = (parameters.patient_message as string) || null;
+
+  const recorded = await recordValidationResult(
+    ctx.conversationId,
+    tenantId,
+    result as 'confirmed' | 'cancelled' | 'reschedule',
+    rescheduleRequest,
+    patientMessage,
+  );
+
+  if (!recorded.recorded) {
+    return JSON.stringify({ error: 'Appointment not found for this conversation' });
+  }
+
+  return JSON.stringify({
+    recorded: true,
+    result,
+  });
+}
+
+// ─── Dispatcher ──────────────────────────────────────────────
+
+const TOOL_HANDLERS: Record<string, (ctx: ToolContext, params: Record<string, unknown>) => Promise<string>> = {
+  check_availability: checkAvailability,
+  reserve_slot: reserveSlot,
+  list_reservations: listReservations,
+  cancel_reservation: cancelReservation,
+  reschedule_reservation: rescheduleReservation,
+  check_patient_history: checkPatientHistory,
+  confirm_appointment_validation: confirmAppointmentValidation,
+};
+
+export const AVAILABLE_TOOLS = Object.keys(TOOL_HANDLERS);
+
+export async function handleWebhookToolCall(
+  toolName: string,
+  ctx: ToolContext,
+  parameters: Record<string, unknown>,
+): Promise<{ result: string; isError: boolean }> {
+  const handler = TOOL_HANDLERS[toolName];
+  if (!handler) {
+    return {
+      result: JSON.stringify({ error: `Unknown tool: ${toolName}` }),
+      isError: true,
+    };
+  }
+
+  try {
+    const result = await handler(ctx, parameters);
+    logger.info('Webhook tool call completed', {
+      toolName,
+      agentId: ctx.agentId,
+      conversationId: ctx.conversationId,
+      resultPreview: result.substring(0, 200),
+    });
+    return { result, isError: false };
+  } catch (err) {
+    logger.error('Webhook tool call failed', {
+      toolName,
+      agentId: ctx.agentId,
+      conversationId: ctx.conversationId,
+      error: (err as Error).message,
+    });
+    return {
+      result: JSON.stringify({ error: (err as Error).message }),
+      isError: true,
+    };
+  }
+}

package/src/modules/webhooks/elevenlabs.routes.ts

@@ -0,0 +1,34 @@
+import { FastifyInstance, FastifyRequest, FastifyReply } from 'fastify';
+import { webhookValidator } from '../../hooks/webhookValidator';
+import { processWebhook } from './elevenlabs.service';
+import { ElevenLabsWebhookPayload } from '../../types';
+import logger from '../../utils/logger';
+
+export default async function elevenlabsWebhookRoutes(fastify: FastifyInstance): Promise<void> {
+  fastify.post('/', {
+    config: { rawBody: true },
+    // preHandler: [webhookValidator] // TODO: re-enable for production
+  }, async (request: FastifyRequest, reply: FastifyReply) => {
+    const payload = request.body as ElevenLabsWebhookPayload;
+
+    logger.info('ElevenLabs webhook received in route handler', {
+      type: payload?.type,
+      conversation_id: payload?.data?.conversation_id,
+      agent_id: payload?.data?.agent_id,
+      status: payload?.data?.status,
+      has_metadata: !!payload?.data?.metadata,
+      has_transcript: !!payload?.data?.transcript,
+    });
+
+    // Respond immediately, process in background
+    reply.status(200).send({ status: 'received' });
+
+    processWebhook(payload).catch(error => {
+      logger.error('Webhook processing failed', {
+        error: (error as Error).message,
+        stack: (error as Error).stack,
+        conversation_id: payload?.data?.conversation_id,
+      });
+    });
+  });
+}