elevenlabs-webhook-nodejs 1.0.0

package/nestjs/src/whatsapp/processors/cost-sweep.processor.ts

@@ -0,0 +1,130 @@
+import { Processor, WorkerHost } from '@nestjs/bullmq';
+import { Logger } from '@nestjs/common';
+import type { Job } from 'bullmq';
+import { PrismaService } from '../../database/prisma.service.js';
+import { ElevenLabsService } from '../../integrations/elevenlabs/elevenlabs.service.js';
+
+/** Max sessions to process per run to avoid API rate limits. */
+const BATCH_SIZE = 20;
+
+/**
+ * Runs every 10 minutes (repeatable job).
+ * Fetches ElevenLabs conversation costs for resolved sessions
+ * that have a conversation ID but no cost recorded yet.
+ */
+@Processor('whatsapp-cost-sweep')
+export class CostSweepProcessor extends WorkerHost {
+  private readonly logger = new Logger(CostSweepProcessor.name);
+
+  constructor(
+    private readonly prisma: PrismaService,
+    private readonly elevenlabs: ElevenLabsService,
+  ) {
+    super();
+  }
+
+  async process(job: Job): Promise<void> {
+    this.logger.debug('Running cost sweep');
+
+    try {
+      // Find resolved sessions with a conversation ID but no cost
+      const sessions = await this.prisma.whatsappSession.findMany({
+        where: {
+          session_status: 'resolved',
+          session_el_conversation_id: { not: null },
+          session_el_cost: null,
+        },
+        select: {
+          session_id: true,
+          session_el_conversation_id: true,
+          session_tenant_id: true,
+        },
+        take: BATCH_SIZE,
+        orderBy: { session_resolved_at: 'asc' },
+      });
+
+      if (sessions.length === 0) {
+        this.logger.debug('No sessions needing cost sweep');
+        return;
+      }
+
+      this.logger.log(`Cost sweep: processing ${sessions.length} sessions`);
+
+      let successCount = 0;
+      let failCount = 0;
+
+      for (const session of sessions) {
+        try {
+          const costData = await this.elevenlabs.getConversationCost(
+            session.session_el_conversation_id!,
+          );
+
+          // The ElevenLabs cost endpoint returns total cost info.
+          // Extract the total cost in USD (or the relevant currency).
+          const totalCost = this.extractCost(costData);
+
+          await this.prisma.whatsappSession.update({
+            where: { session_id: session.session_id },
+            data: { session_el_cost: totalCost },
+          });
+
+          successCount++;
+
+          this.logger.debug(
+            `Session ${session.session_id}: cost = ${totalCost}`,
+          );
+        } catch (error) {
+          failCount++;
+          this.logger.warn(
+            `Failed to fetch cost for session ${session.session_id} (conv=${session.session_el_conversation_id}): ${(error as Error).message}`,
+          );
+          // Continue with next session
+        }
+      }
+
+      this.logger.log(
+        `Cost sweep complete: ${successCount} updated, ${failCount} failed out of ${sessions.length}`,
+      );
+    } catch (error) {
+      this.logger.error(
+        `Cost sweep failed: ${(error as Error).message}`,
+        (error as Error).stack,
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Extract the total cost from the ElevenLabs cost response.
+   * The API response shape may vary — we handle common formats gracefully.
+   */
+  private extractCost(costData: any): number {
+    // Primary: costData.total_cost_usd or costData.total_cost
+    if (typeof costData?.total_cost_usd === 'number') {
+      return costData.total_cost_usd;
+    }
+    if (typeof costData?.total_cost === 'number') {
+      return costData.total_cost;
+    }
+    // Fallback: costData.cost
+    if (typeof costData?.cost === 'number') {
+      return costData.cost;
+    }
+    // Sum cost_breakdown items if present
+    if (Array.isArray(costData?.cost_breakdown)) {
+      return costData.cost_breakdown.reduce(
+        (sum: number, item: any) => sum + (item.cost ?? 0),
+        0,
+      );
+    }
+    // If the entire response is a number
+    if (typeof costData === 'number') {
+      return costData;
+    }
+
+    this.logger.warn(
+      `Unexpected cost response shape: ${JSON.stringify(costData).substring(0, 200)}`,
+    );
+    return 0;
+  }
+}

package/nestjs/src/whatsapp/processors/grace.processor.ts

@@ -0,0 +1,191 @@
+import { Processor, WorkerHost } from '@nestjs/bullmq';
+import { Logger } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { EventEmitter2 } from '@nestjs/event-emitter';
+import type { Job } from 'bullmq';
+import { PrismaService } from '../../database/prisma.service.js';
+
+@Processor('whatsapp-grace')
+export class GraceProcessor extends WorkerHost {
+  private readonly logger = new Logger(GraceProcessor.name);
+
+  constructor(
+    private readonly prisma: PrismaService,
+    private readonly config: ConfigService,
+    private readonly eventEmitter: EventEmitter2,
+  ) {
+    super();
+  }
+
+  async process(job: Job<{ sessionId: string }>): Promise<void> {
+    const { sessionId } = job.data;
+    this.logger.debug(`Grace period expired for session ${sessionId}`);
+
+    try {
+      // 1. Load session with clinic info
+      const session = await this.prisma.whatsappSession.findUnique({
+        where: { session_id: sessionId },
+        include: {
+          clinic: {
+            select: {
+              clinic_id: true,
+              clinic_ai_shift_enabled: true,
+              clinic_ai_shift_schedule: true,
+              clinic_timezone: true,
+            },
+          },
+        },
+      });
+
+      if (!session) {
+        this.logger.warn(`Session ${sessionId} not found, skipping grace expiry`);
+        return;
+      }
+
+      // 2. Verify session is still in waiting status
+      if (session.session_status !== 'waiting') {
+        this.logger.debug(
+          `Session ${sessionId} is no longer waiting (status=${session.session_status}), skipping`,
+        );
+        return;
+      }
+
+      // 3. Check if AI should activate based on shift schedule
+      const shouldActivateAi = this.shouldAiActivate(
+        session.clinic.clinic_ai_shift_enabled,
+        session.clinic.clinic_ai_shift_schedule as any[],
+        session.clinic.clinic_timezone,
+      );
+
+      if (shouldActivateAi) {
+        // 4. AI should activate: transition to active
+        await this.prisma.whatsappSession.update({
+          where: { session_id: sessionId },
+          data: {
+            session_status: 'active',
+            session_started_at: new Date(),
+          },
+        });
+
+        this.logger.log(`Session ${sessionId} activated (grace expired, AI shift active)`);
+
+        this.eventEmitter.emit('whatsapp.session.activated', {
+          sessionId,
+          chatId: session.session_chat_id,
+          tenantId: session.session_tenant_id,
+          clinicId: session.session_clinic_id,
+        });
+
+        // Emit status event for real-time dashboard
+        this.eventEmitter.emit('chat.session.status', {
+          sessionId,
+          chatId: session.session_chat_id,
+          tenantId: session.session_tenant_id,
+          status: 'active',
+        });
+      } else {
+        // 5. AI should NOT activate (within clinic hours): resolve as manual
+        await this.prisma.whatsappSession.update({
+          where: { session_id: sessionId },
+          data: {
+            session_status: 'resolved',
+            session_resolved_by: 'manual',
+            session_resolved_at: new Date(),
+          },
+        });
+
+        // Clear chat active session
+        await this.prisma.whatsappChat.update({
+          where: { chat_id: session.session_chat_id },
+          data: { chat_active_session_id: null },
+        });
+
+        this.logger.log(
+          `Session ${sessionId} resolved as manual (grace expired, within clinic hours)`,
+        );
+
+        this.eventEmitter.emit('chat.session.status', {
+          sessionId,
+          chatId: session.session_chat_id,
+          tenantId: session.session_tenant_id,
+          status: 'resolved',
+          resolvedBy: 'manual',
+        });
+      }
+    } catch (error) {
+      this.logger.error(
+        `Failed to process grace expiry for session ${sessionId}: ${(error as Error).message}`,
+        (error as Error).stack,
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Determine whether the AI should activate.
+   *
+   * If ai_shift_enabled is false, AI is always active.
+   * If ai_shift_enabled is true, AI is active OUTSIDE working hours
+   * (the shift schedule defines when humans work, AI handles the rest).
+   */
+  private shouldAiActivate(
+    aiShiftEnabled: boolean,
+    aiShiftSchedule: any[],
+    timezone: string,
+  ): boolean {
+    // If shift scheduling is not enabled, AI is always active
+    if (!aiShiftEnabled) {
+      return true;
+    }
+
+    // If no schedule defined, AI is always active
+    if (!aiShiftSchedule || !Array.isArray(aiShiftSchedule) || aiShiftSchedule.length === 0) {
+      return true;
+    }
+
+    try {
+      // Get current time in the clinic's timezone
+      const now = new Date();
+      const formatter = new Intl.DateTimeFormat('en-US', {
+        timeZone: timezone,
+        hour: '2-digit',
+        minute: '2-digit',
+        hour12: false,
+        weekday: 'short',
+      });
+      const parts = formatter.formatToParts(now);
+      const hour = parseInt(parts.find((p) => p.type === 'hour')?.value ?? '0', 10);
+      const minute = parseInt(parts.find((p) => p.type === 'minute')?.value ?? '0', 10);
+      const weekday = parts.find((p) => p.type === 'weekday')?.value?.toLowerCase() ?? '';
+
+      const currentMinutes = hour * 60 + minute;
+
+      // Map weekday abbreviation to day index
+      const dayMap: Record<string, number> = {
+        sun: 0, mon: 1, tue: 2, wed: 3, thu: 4, fri: 5, sat: 6,
+      };
+      const currentDay = dayMap[weekday] ?? 0;
+
+      // Check if current time falls within any working hours block
+      // Schedule format: [{ day: 0-6, start: "09:00", end: "18:00" }, ...]
+      const isWithinWorkingHours = aiShiftSchedule.some((slot: any) => {
+        if (slot.day !== currentDay) return false;
+
+        const [startH, startM] = (slot.start as string).split(':').map(Number);
+        const [endH, endM] = (slot.end as string).split(':').map(Number);
+        const startMinutes = startH * 60 + startM;
+        const endMinutes = endH * 60 + endM;
+
+        return currentMinutes >= startMinutes && currentMinutes < endMinutes;
+      });
+
+      // AI is active OUTSIDE working hours
+      return !isWithinWorkingHours;
+    } catch (error) {
+      this.logger.warn(
+        `Error checking AI shift schedule, defaulting to AI active: ${(error as Error).message}`,
+      );
+      return true;
+    }
+  }
+}

package/nestjs/src/whatsapp/processors/message-buffer.processor.ts

@@ -0,0 +1,138 @@
+import { Processor, WorkerHost } from '@nestjs/bullmq';
+import { Logger } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { EventEmitter2 } from '@nestjs/event-emitter';
+import type { Job } from 'bullmq';
+import { PrismaService } from '../../database/prisma.service.js';
+import { EncryptionService } from '../../integrations/encryption/encryption.service.js';
+
+@Processor('whatsapp-message-buffer')
+export class MessageBufferProcessor extends WorkerHost {
+  private readonly logger = new Logger(MessageBufferProcessor.name);
+  private readonly messageEncryptionKey: string;
+
+  constructor(
+    private readonly prisma: PrismaService,
+    private readonly encryption: EncryptionService,
+    private readonly config: ConfigService,
+    private readonly eventEmitter: EventEmitter2,
+  ) {
+    super();
+    this.messageEncryptionKey = this.config.getOrThrow<string>(
+      'MESSAGE_ENCRYPTION_KEY',
+    );
+  }
+
+  async process(
+    job: Job<{ sessionId: string; messageId: string }>,
+  ): Promise<void> {
+    const { sessionId, messageId } = job.data;
+    this.logger.debug(
+      `Buffered message ${messageId} for session ${sessionId}`,
+    );
+
+    try {
+      // 1. Load the session
+      const session = await this.prisma.whatsappSession.findUnique({
+        where: { session_id: sessionId },
+        select: {
+          session_id: true,
+          session_status: true,
+          session_tenant_id: true,
+          session_chat_id: true,
+          session_clinic_id: true,
+        },
+      });
+
+      if (!session) {
+        this.logger.warn(`Session ${sessionId} not found, skipping buffer`);
+        return;
+      }
+
+      // 2. Verify session is still active
+      if (session.session_status !== 'active') {
+        this.logger.debug(
+          `Session ${sessionId} is not active (status=${session.session_status}), skipping buffer flush`,
+        );
+        return;
+      }
+
+      // 3. Find all messages from the contact after the last AI response
+      const lastAiMessage = await this.prisma.whatsappMessage.findFirst({
+        where: {
+          msg_session_id: sessionId,
+          msg_sender: { in: ['ai', 'human'] },
+        },
+        orderBy: { msg_created_at: 'desc' },
+        select: { msg_created_at: true },
+      });
+
+      const contactMessages = await this.prisma.whatsappMessage.findMany({
+        where: {
+          msg_session_id: sessionId,
+          msg_sender: 'contact',
+          ...(lastAiMessage
+            ? { msg_created_at: { gt: lastAiMessage.msg_created_at } }
+            : {}),
+        },
+        orderBy: { msg_created_at: 'asc' },
+        select: {
+          msg_id: true,
+          msg_text: true,
+          msg_media_type: true,
+        },
+      });
+
+      if (contactMessages.length === 0) {
+        this.logger.debug(
+          `No unbuffered contact messages found for session ${sessionId}`,
+        );
+        return;
+      }
+
+      // 4. Decrypt message texts
+      const decryptedTexts: string[] = [];
+      for (const msg of contactMessages) {
+        try {
+          const text = this.encryption.decrypt(
+            msg.msg_text,
+            this.messageEncryptionKey,
+          );
+          if (text.trim()) {
+            decryptedTexts.push(text);
+          } else if (msg.msg_media_type) {
+            decryptedTexts.push(`[${msg.msg_media_type}]`);
+          }
+        } catch {
+          this.logger.warn(
+            `Failed to decrypt message ${msg.msg_id}, using placeholder`,
+          );
+          decryptedTexts.push('[mesaj okunamadı]');
+        }
+      }
+
+      // 5. Combine into a single text payload
+      const combinedText = decryptedTexts.join('\n');
+
+      this.logger.log(
+        `Buffered ${contactMessages.length} messages for session ${sessionId}: ${combinedText.substring(0, 100)}...`,
+      );
+
+      // 6. Emit event for AI WebSocket handler to consume
+      this.eventEmitter.emit('whatsapp.messages.buffered', {
+        sessionId,
+        chatId: session.session_chat_id,
+        tenantId: session.session_tenant_id,
+        clinicId: session.session_clinic_id,
+        combinedText,
+        messageCount: contactMessages.length,
+      });
+    } catch (error) {
+      this.logger.error(
+        `Failed to process buffered message for session ${sessionId}: ${(error as Error).message}`,
+        (error as Error).stack,
+      );
+      throw error;
+    }
+  }
+}

package/nestjs/src/whatsapp/processors/message-cleanup.processor.ts

@@ -0,0 +1,148 @@
+import { Processor, WorkerHost } from '@nestjs/bullmq';
+import { Logger } from '@nestjs/common';
+import type { Job } from 'bullmq';
+import { PrismaService } from '../../database/prisma.service.js';
+import { MinioService } from '../../integrations/minio/minio.service.js';
+
+/**
+ * Runs daily. Deletes old messages beyond retention period per clinic.
+ * For messages with media, also removes the corresponding MinIO objects.
+ */
+@Processor('whatsapp-message-cleanup')
+export class MessageCleanupProcessor extends WorkerHost {
+  private readonly logger = new Logger(MessageCleanupProcessor.name);
+
+  /** Default retention if not configured on the clinic. */
+  private static readonly DEFAULT_RETENTION_DAYS = 7;
+
+  /** Batch size for deletion to avoid long-running transactions. */
+  private static readonly BATCH_SIZE = 500;
+
+  constructor(
+    private readonly prisma: PrismaService,
+    private readonly minio: MinioService,
+  ) {
+    super();
+  }
+
+  async process(job: Job): Promise<void> {
+    this.logger.debug('Running daily message cleanup');
+
+    try {
+      // Fetch all active clinics with their retention setting
+      const clinics = await this.prisma.clinic.findMany({
+        where: { clinic_is_active: true },
+        select: {
+          clinic_id: true,
+          clinic_name: true,
+          clinic_message_retention_days: true,
+        },
+      });
+
+      let totalDeleted = 0;
+      let totalMediaDeleted = 0;
+
+      for (const clinic of clinics) {
+        const retentionDays =
+          clinic.clinic_message_retention_days ??
+          MessageCleanupProcessor.DEFAULT_RETENTION_DAYS;
+
+        const cutoff = new Date();
+        cutoff.setDate(cutoff.getDate() - retentionDays);
+
+        try {
+          const result = await this.cleanupClinicMessages(
+            clinic.clinic_id,
+            cutoff,
+          );
+          totalDeleted += result.messagesDeleted;
+          totalMediaDeleted += result.mediaDeleted;
+
+          if (result.messagesDeleted > 0) {
+            this.logger.log(
+              `Clinic "${clinic.clinic_name}": deleted ${result.messagesDeleted} messages, ${result.mediaDeleted} media objects (retention=${retentionDays}d)`,
+            );
+          }
+        } catch (error) {
+          this.logger.error(
+            `Failed to cleanup messages for clinic ${clinic.clinic_id}: ${(error as Error).message}`,
+          );
+          // Continue with next clinic
+        }
+      }
+
+      this.logger.log(
+        `Message cleanup complete: ${totalDeleted} messages, ${totalMediaDeleted} media objects deleted across ${clinics.length} clinics`,
+      );
+    } catch (error) {
+      this.logger.error(
+        `Message cleanup failed: ${(error as Error).message}`,
+        (error as Error).stack,
+      );
+      throw error;
+    }
+  }
+
+  private async cleanupClinicMessages(
+    clinicId: string,
+    cutoff: Date,
+  ): Promise<{ messagesDeleted: number; mediaDeleted: number }> {
+    let messagesDeleted = 0;
+    let mediaDeleted = 0;
+
+    // Get chat IDs for this clinic
+    const chats = await this.prisma.whatsappChat.findMany({
+      where: { chat_clinic_id: clinicId },
+      select: { chat_id: true },
+    });
+
+    if (chats.length === 0) return { messagesDeleted, mediaDeleted };
+
+    const chatIds = chats.map((c) => c.chat_id);
+
+    // Process in batches to avoid memory issues
+    let hasMore = true;
+    while (hasMore) {
+      // Find messages with media to delete from MinIO first
+      const mediaMessages = await this.prisma.whatsappMessage.findMany({
+        where: {
+          msg_chat_id: { in: chatIds },
+          msg_created_at: { lt: cutoff },
+          msg_media_key: { not: null },
+        },
+        select: { msg_id: true, msg_media_key: true },
+        take: MessageCleanupProcessor.BATCH_SIZE,
+      });
+
+      // Delete media from MinIO
+      for (const msg of mediaMessages) {
+        if (msg.msg_media_key) {
+          try {
+            await this.minio.removeObject(msg.msg_media_key);
+            mediaDeleted++;
+          } catch (error) {
+            this.logger.warn(
+              `Failed to delete media object ${msg.msg_media_key}: ${(error as Error).message}`,
+            );
+            // Continue even if media deletion fails
+          }
+        }
+      }
+
+      // Batch delete messages from DB
+      const deleted = await this.prisma.whatsappMessage.deleteMany({
+        where: {
+          msg_chat_id: { in: chatIds },
+          msg_created_at: { lt: cutoff },
+        },
+      });
+
+      messagesDeleted += deleted.count;
+
+      // If we deleted fewer than batch size, we're done
+      hasMore = deleted.count >= MessageCleanupProcessor.BATCH_SIZE;
+    }
+
+    return { messagesDeleted, mediaDeleted };
+  }
+}