elevenlabs-webhook-nodejs 1.0.0

package/src/modules/billing/billing.service.ts

@@ -0,0 +1,562 @@
+import mongoose from 'mongoose';
+import BillingEvent from './billing.model';
+import Call from '../calls/call.model';
+import Tenant from '../tenants/tenant.model';
+import Plan from '../plans/plan.model';
+import Payment from './payment.model';
+import WhatsAppMessage from '../whatsapp/whatsapp-message.model';
+import WhatsAppSession from '../whatsapp/whatsapp-session.model';
+import SttUsage from '../whatsapp/stt-usage.model';
+import BillingPeriodSnapshot from './billing-period-snapshot.model';
+import BillingAlert, { AlertType, AlertService } from './billing-alert.model';
+import netgsmService from '../../services/netgsm.service';
+import logger from '../../utils/logger';
+
+// Per-minute call rate in TRY
+const CALL_RATE_PER_MINUTE = 1.5;
+
+/**
+ * Logs a call_charge billing event after a completed call.
+ */
+export async function logCallCharge(
+  tenantId: string,
+  callId: string,
+  durationSeconds: number
+): Promise<void> {
+  const minutes = Math.ceil(durationSeconds / 60);
+  const amount = minutes * CALL_RATE_PER_MINUTE;
+
+  await BillingEvent.create({
+    tenant_id: tenantId,
+    type: 'call_charge',
+    amount,
+    currency: 'TRY',
+    call_id: callId,
+    description: `Arama ucreti: ${minutes} dk`
+  });
+
+  logger.info('Call charge logged', { tenant_id: tenantId, call_id: callId, amount, minutes });
+}
+
+/**
+ * Returns usage summary for the active billing period.
+ * Period is determined by: active payment > last payment end > tenant creation date.
+ */
+export async function getUsageSummary(tenantId: string) {
+  const now = new Date();
+  const tenantOid = new mongoose.Types.ObjectId(tenantId);
+
+  const tenant = await Tenant.findById(tenantId).select('plan createdAt').lean();
+
+  // Resolve billing period from payments
+  const activePayment = await Payment.findOne({
+    tenant_id: tenantOid,
+    type: 'subscription',
+    period_start: { $lte: now },
+    period_end: { $gte: now },
+  }).sort({ period_start: -1 }).lean();
+
+  let periodStart: Date;
+  let periodEnd: Date;
+
+  if (activePayment) {
+    periodStart = activePayment.period_start;
+    periodEnd = activePayment.period_end;
+  } else {
+    const lastPayment = await Payment.findOne({
+      tenant_id: tenantOid,
+      type: 'subscription',
+    }).sort({ period_end: -1 }).lean();
+
+    periodStart = lastPayment?.period_end || tenant?.createdAt || now;
+    periodEnd = now;
+  }
+
+  const [callStats, chargeResult, topUpResult, waMessageStats, waSessionStats, sttStats] = await Promise.all([
+    // Call stats
+    Call.aggregate([
+      { $match: { tenant_id: tenantOid, createdAt: { $gte: periodStart, $lte: periodEnd } } },
+      {
+        $group: {
+          _id: null,
+          total_calls: { $sum: 1 },
+          total_duration_seconds: { $sum: '$duration_seconds' },
+          inbound_calls: { $sum: { $cond: [{ $eq: ['$direction', 'inbound'] }, 1, 0] } },
+          outbound_calls: { $sum: { $cond: [{ $eq: ['$direction', 'outbound'] }, 1, 0] } },
+          inbound_duration_seconds: { $sum: { $cond: [{ $eq: ['$direction', 'inbound'] }, '$duration_seconds', 0] } },
+          outbound_duration_seconds: { $sum: { $cond: [{ $eq: ['$direction', 'outbound'] }, '$duration_seconds', 0] } },
+        },
+      },
+    ]).then(r => r[0]),
+
+    // Call charges
+    BillingEvent.aggregate([
+      { $match: { tenant_id: tenantOid, type: 'call_charge', createdAt: { $gte: periodStart, $lte: periodEnd } } },
+      { $group: { _id: null, total_charges: { $sum: '$amount' } } },
+    ]).then(r => r[0]),
+
+    // Top-up extra minutes overlapping the period
+    Payment.aggregate([
+      { $match: { tenant_id: tenantOid, type: 'top_up', period_start: { $lte: periodEnd }, period_end: { $gte: periodStart } } },
+      { $group: { _id: null, total_extra: { $sum: '$extra_minutes' } } },
+    ]).then(r => r[0]),
+
+    // WhatsApp message stats
+    WhatsAppMessage.aggregate([
+      { $match: { tenant_id: tenantOid, createdAt: { $gte: periodStart, $lte: periodEnd } } },
+      {
+        $group: {
+          _id: null,
+          total_messages: { $sum: 1 },
+          ai_messages: { $sum: { $cond: [{ $eq: ['$sender_name', 'AI'] }, 1, 0] } },
+          billable_chats: { $addToSet: { $cond: [{ $eq: ['$sender_name', 'AI'] }, '$chat_id', '$$REMOVE'] } },
+        },
+      },
+    ]).then(r => r[0]),
+
+    // WhatsApp session stats
+    WhatsAppSession.aggregate([
+      { $match: { tenant_id: tenantOid, createdAt: { $gte: periodStart, $lte: periodEnd } } },
+      {
+        $group: {
+          _id: null,
+          total_sessions: { $sum: 1 },
+          elevenlabs_cost: { $sum: { $ifNull: ['$elevenlabs_cost', 0] } },
+        },
+      },
+    ]).then(r => r[0]),
+
+    // STT usage stats
+    SttUsage.aggregate([
+      { $match: { tenant_id: tenantOid, createdAt: { $gte: periodStart, $lte: periodEnd } } },
+      {
+        $group: {
+          _id: null,
+          stt_count: { $sum: 1 },
+          stt_seconds: { $sum: '$duration_seconds' },
+        },
+      },
+    ]).then(r => r[0]),
+  ]);
+
+  const totalDuration = callStats?.total_duration_seconds || 0;
+  const usedMinutes = Math.ceil(totalDuration / 60);
+  const inboundCalls = callStats?.inbound_calls || 0;
+  const outboundCalls = callStats?.outbound_calls || 0;
+  const inboundMinutes = Math.ceil((callStats?.inbound_duration_seconds || 0) / 60);
+  const outboundMinutes = Math.ceil((callStats?.outbound_duration_seconds || 0) / 60);
+
+  // Lookup plan details
+  const plan = tenant?.plan ? await Plan.findOne({ slug: tenant.plan }).lean() : null;
+  const includedMinutes = plan?.included_minutes || 0;
+  const extraMinutes = topUpResult?.total_extra || 0;
+  const totalQuota = includedMinutes + extraMinutes;
+  const remaining = Math.max(0, totalQuota - usedMinutes);
+  const overage = Math.max(0, usedMinutes - totalQuota);
+  const percentage = totalQuota > 0 ? Math.min(100, Math.round((usedMinutes / totalQuota) * 100)) : 0;
+
+  return {
+    period_start: periodStart,
+    period_end: periodEnd,
+    // Call metrics
+    total_calls: callStats?.total_calls || 0,
+    total_duration_seconds: totalDuration,
+    total_duration_minutes: usedMinutes,
+    inbound_calls: inboundCalls,
+    outbound_calls: outboundCalls,
+    total_charges: chargeResult?.total_charges || 0,
+    currency: 'TRY',
+    // Plan metrics (legacy combined)
+    plan_name: plan?.name || tenant?.plan || 'Plansiz',
+    plan_slug: plan?.slug || tenant?.plan || '',
+    included_minutes: includedMinutes,
+    extra_minutes: extraMinutes,
+    total_quota: totalQuota,
+    used_minutes: usedMinutes,
+    remaining_minutes: remaining,
+    usage_percentage: percentage,
+    overage_minutes: overage,
+    // Per-service quotas
+    included_inbound_minutes: plan?.included_inbound_minutes || 0,
+    included_inbound_calls: plan?.included_inbound_calls || 0,
+    included_outbound_minutes: plan?.included_outbound_minutes || 0,
+    included_outbound_calls: plan?.included_outbound_calls || 0,
+    included_wa_chats: plan?.included_wa_chats || 0,
+    // Per-service usage
+    inbound_used_minutes: inboundMinutes,
+    inbound_used_calls: inboundCalls,
+    outbound_used_minutes: outboundMinutes,
+    outbound_used_calls: outboundCalls,
+    wa_used_chats: waMessageStats?.billable_chats?.length || 0,
+    // WhatsApp metrics
+    wa_billable_chats: waMessageStats?.billable_chats?.length || 0,
+    wa_total_sessions: waSessionStats?.total_sessions || 0,
+    wa_total_messages: waMessageStats?.total_messages || 0,
+    wa_ai_messages: waMessageStats?.ai_messages || 0,
+    wa_elevenlabs_cost: waSessionStats?.elevenlabs_cost || 0,
+    // STT metrics
+    wa_stt_count: sttStats?.stt_count || 0,
+    wa_stt_seconds: sttStats?.stt_seconds || 0,
+  };
+}
+
+/**
+ * Returns daily usage trend for the active billing period.
+ */
+export async function getDailyTrend(tenantId: string) {
+  const now = new Date();
+  const tenantOid = new mongoose.Types.ObjectId(tenantId);
+
+  const tenant = await Tenant.findById(tenantId).select('plan createdAt').lean();
+
+  // Resolve billing period (same logic as getUsageSummary)
+  const activePayment = await Payment.findOne({
+    tenant_id: tenantOid,
+    type: 'subscription',
+    period_start: { $lte: now },
+    period_end: { $gte: now },
+  }).sort({ period_start: -1 }).lean();
+
+  let periodStart: Date;
+  let periodEnd: Date;
+
+  if (activePayment) {
+    periodStart = activePayment.period_start;
+    periodEnd = activePayment.period_end;
+  } else {
+    const lastPayment = await Payment.findOne({
+      tenant_id: tenantOid,
+      type: 'subscription',
+    }).sort({ period_end: -1 }).lean();
+    periodStart = lastPayment?.period_end || tenant?.createdAt || now;
+    periodEnd = now;
+  }
+
+  const [callDaily, waDaily] = await Promise.all([
+    // Daily inbound calls
+    Call.aggregate([
+      { $match: { tenant_id: tenantOid, direction: 'inbound', createdAt: { $gte: periodStart, $lte: periodEnd } } },
+      {
+        $group: {
+          _id: { $dateToString: { format: '%Y-%m-%d', date: '$createdAt' } },
+          calls: { $sum: 1 },
+          minutes: { $sum: { $ceil: { $divide: ['$duration_seconds', 60] } } },
+        },
+      },
+      { $sort: { _id: 1 } },
+    ]),
+
+    // Daily WhatsApp messages (AI only)
+    WhatsAppMessage.aggregate([
+      { $match: { tenant_id: tenantOid, sender_name: 'AI', createdAt: { $gte: periodStart, $lte: periodEnd } } },
+      {
+        $group: {
+          _id: { $dateToString: { format: '%Y-%m-%d', date: '$createdAt' } },
+          messages: { $sum: 1 },
+        },
+      },
+      { $sort: { _id: 1 } },
+    ]),
+  ]);
+
+  // Merge into a single daily array
+  const dayMap = new Map<string, { date: string; inbound_calls: number; inbound_minutes: number; wa_messages: number }>();
+
+  // Fill all days in period
+  const cursor = new Date(periodStart);
+  const end = periodEnd < now ? periodEnd : now;
+  while (cursor <= end) {
+    const key = cursor.toISOString().split('T')[0];
+    dayMap.set(key, { date: key, inbound_calls: 0, inbound_minutes: 0, wa_messages: 0 });
+    cursor.setDate(cursor.getDate() + 1);
+  }
+
+  for (const d of callDaily) {
+    const entry = dayMap.get(d._id);
+    if (entry) {
+      entry.inbound_calls = d.calls;
+      entry.inbound_minutes = d.minutes;
+    }
+  }
+  for (const d of waDaily) {
+    const entry = dayMap.get(d._id);
+    if (entry) {
+      entry.wa_messages = d.messages;
+    }
+  }
+
+  return Array.from(dayMap.values());
+}
+
+/**
+ * Snapshots a billing period's usage into an immutable record.
+ * Called when a new subscription payment is created.
+ */
+export async function snapshotPeriod(
+  tenantId: string,
+  periodStart: Date,
+  periodEnd: Date,
+  paymentId: string,
+): Promise<void> {
+  const tenantOid = new mongoose.Types.ObjectId(tenantId);
+
+  // Check if snapshot already exists for this payment
+  const existing = await BillingPeriodSnapshot.findOne({ payment_id: paymentId });
+  if (existing) return;
+
+  const tenant = await Tenant.findById(tenantId).select('plan').lean();
+  const plan = tenant?.plan ? await Plan.findOne({ slug: tenant.plan }).lean() : null;
+
+  const [callStats, chargeResult, waMessageStats, waSessionStats, sttStats] = await Promise.all([
+    Call.aggregate([
+      { $match: { tenant_id: tenantOid, createdAt: { $gte: periodStart, $lte: periodEnd } } },
+      {
+        $group: {
+          _id: null,
+          total_calls: { $sum: 1 },
+          inbound_calls: { $sum: { $cond: [{ $eq: ['$direction', 'inbound'] }, 1, 0] } },
+          outbound_calls: { $sum: { $cond: [{ $eq: ['$direction', 'outbound'] }, 1, 0] } },
+          inbound_duration_seconds: { $sum: { $cond: [{ $eq: ['$direction', 'inbound'] }, '$duration_seconds', 0] } },
+          outbound_duration_seconds: { $sum: { $cond: [{ $eq: ['$direction', 'outbound'] }, '$duration_seconds', 0] } },
+        },
+      },
+    ]).then(r => r[0]),
+
+    BillingEvent.aggregate([
+      { $match: { tenant_id: tenantOid, type: 'call_charge', createdAt: { $gte: periodStart, $lte: periodEnd } } },
+      { $group: { _id: null, total_charges: { $sum: '$amount' } } },
+    ]).then(r => r[0]),
+
+    WhatsAppMessage.aggregate([
+      { $match: { tenant_id: tenantOid, createdAt: { $gte: periodStart, $lte: periodEnd } } },
+      {
+        $group: {
+          _id: null,
+          total_messages: { $sum: 1 },
+          ai_messages: { $sum: { $cond: [{ $eq: ['$sender_name', 'AI'] }, 1, 0] } },
+          billable_chats: { $addToSet: { $cond: [{ $eq: ['$sender_name', 'AI'] }, '$chat_id', '$$REMOVE'] } },
+        },
+      },
+    ]).then(r => r[0]),
+
+    WhatsAppSession.aggregate([
+      { $match: { tenant_id: tenantOid, createdAt: { $gte: periodStart, $lte: periodEnd } } },
+      {
+        $group: {
+          _id: null,
+          total_sessions: { $sum: 1 },
+          elevenlabs_cost: { $sum: { $ifNull: ['$elevenlabs_cost', 0] } },
+        },
+      },
+    ]).then(r => r[0]),
+
+    SttUsage.aggregate([
+      { $match: { tenant_id: tenantOid, createdAt: { $gte: periodStart, $lte: periodEnd } } },
+      { $group: { _id: null, stt_count: { $sum: 1 }, stt_seconds: { $sum: '$duration_seconds' } } },
+    ]).then(r => r[0]),
+  ]);
+
+  await BillingPeriodSnapshot.create({
+    tenant_id: tenantOid,
+    payment_id: paymentId,
+    period_start: periodStart,
+    period_end: periodEnd,
+    plan_name: plan?.name || tenant?.plan || '',
+    plan_slug: plan?.slug || tenant?.plan || '',
+    total_calls: callStats?.total_calls || 0,
+    inbound_calls: callStats?.inbound_calls || 0,
+    inbound_minutes: Math.ceil((callStats?.inbound_duration_seconds || 0) / 60),
+    outbound_calls: callStats?.outbound_calls || 0,
+    outbound_minutes: Math.ceil((callStats?.outbound_duration_seconds || 0) / 60),
+    total_charges: chargeResult?.total_charges || 0,
+    included_minutes: plan?.included_minutes || 0,
+    included_inbound_minutes: plan?.included_inbound_minutes || 0,
+    included_inbound_calls: plan?.included_inbound_calls || 0,
+    included_outbound_minutes: plan?.included_outbound_minutes || 0,
+    included_outbound_calls: plan?.included_outbound_calls || 0,
+    included_wa_chats: plan?.included_wa_chats || 0,
+    wa_billable_chats: waMessageStats?.billable_chats?.length || 0,
+    wa_total_sessions: waSessionStats?.total_sessions || 0,
+    wa_total_messages: waMessageStats?.total_messages || 0,
+    wa_ai_messages: waMessageStats?.ai_messages || 0,
+    wa_elevenlabs_cost: waSessionStats?.elevenlabs_cost || 0,
+    wa_stt_count: sttStats?.stt_count || 0,
+    wa_stt_seconds: sttStats?.stt_seconds || 0,
+  });
+
+  logger.info('Billing period snapshot created', { tenantId, periodStart, periodEnd, paymentId });
+}
+
+/**
+ * Daily sweep: find payments whose period ended yesterday and create snapshots.
+ * Should run at 00:05 every day.
+ */
+export async function snapshotExpiredPeriods(): Promise<void> {
+  const now = new Date();
+  const yesterday = new Date(now);
+  yesterday.setDate(yesterday.getDate() - 1);
+  yesterday.setHours(0, 0, 0, 0);
+
+  const todayStart = new Date(now);
+  todayStart.setHours(0, 0, 0, 0);
+
+  // Find subscription payments that ended yesterday
+  const expiredPayments = await Payment.find({
+    type: 'subscription',
+    period_end: { $gte: yesterday, $lt: todayStart },
+  }).lean();
+
+  if (expiredPayments.length === 0) return;
+
+  logger.info('Billing period snapshot sweep', { count: expiredPayments.length });
+
+  for (const payment of expiredPayments) {
+    try {
+      await snapshotPeriod(
+        payment.tenant_id.toString(),
+        payment.period_start,
+        payment.period_end,
+        payment._id.toString(),
+      );
+    } catch (err) {
+      logger.error('Failed to snapshot expired period', {
+        paymentId: payment._id,
+        tenantId: payment.tenant_id,
+        error: (err as Error).message,
+      });
+    }
+  }
+}
+
+// ─── Billing SMS Alerts ──────────────────────────────────────
+
+const THRESHOLDS: { pct: number; type: AlertType }[] = [
+  { pct: 100, type: 'usage_100' },
+  { pct: 90, type: 'usage_90' },
+  { pct: 75, type: 'usage_75' },
+];
+
+const ALERT_MESSAGES: Record<AlertType, string> = {
+  usage_75: '[Asistan7/24] Kullaniminiz %75\'e ulasti. Detaylar icin panele bakin.',
+  usage_90: '[Asistan7/24] Kullaniminiz %90\'a ulasti. Detaylar icin panele bakin.',
+  usage_100: '[Asistan7/24] Kullaniminiz %100\'e ulasti. Detaylar icin panele bakin.',
+  period_expiring: '[Asistan7/24] Fatura doneminiz 3 gun icinde sona erecek. Detaylar icin panele bakin.',
+};
+
+/**
+ * Daily check: send SMS alerts for usage thresholds and expiring billing periods.
+ * Should run at 09:00 Istanbul.
+ */
+export async function checkAndSendBillingAlerts(): Promise<void> {
+  const now = new Date();
+
+  // Find all active subscriptions
+  const activePayments = await Payment.find({
+    type: 'subscription',
+    period_start: { $lte: now },
+    period_end: { $gte: now },
+  }).lean();
+
+  if (activePayments.length === 0) return;
+
+  logger.info('Billing alert check started', { activePayments: activePayments.length });
+
+  for (const payment of activePayments) {
+    try {
+      const tenantId = payment.tenant_id.toString();
+      const paymentId = payment._id.toString();
+
+      // Check tenant has SMS enabled
+      const tenant = await Tenant.findById(tenantId).lean();
+      if (!tenant) continue;
+      if (!tenant.enabled_features.includes('sms_notifications')) continue;
+
+      const smsPhones = tenant.settings?.whatsapp_agent?.sms_notification_phones || [];
+      if (smsPhones.length === 0 || !tenant.settings?.whatsapp_agent?.sms_notification_enabled) continue;
+
+      const usage = await getUsageSummary(tenantId);
+
+      // Check usage thresholds for each service
+      const quotaChecks: { service: AlertService; used: number; quota: number }[] = [];
+
+      if (usage.included_inbound_minutes > 0) {
+        quotaChecks.push({ service: 'inbound_minutes', used: usage.inbound_used_minutes, quota: usage.included_inbound_minutes });
+      }
+      if (usage.included_inbound_calls > 0) {
+        quotaChecks.push({ service: 'inbound_calls', used: usage.inbound_used_calls, quota: usage.included_inbound_calls });
+      }
+      if (usage.included_wa_chats > 0) {
+        quotaChecks.push({ service: 'wa_chats', used: usage.wa_used_chats, quota: usage.included_wa_chats });
+      }
+
+      for (const check of quotaChecks) {
+        const pct = check.quota > 0 ? (check.used / check.quota) * 100 : 0;
+
+        // Find highest threshold crossed
+        for (const threshold of THRESHOLDS) {
+          if (pct >= threshold.pct) {
+            await sendAlertIfNew(tenantId, threshold.type, check.service, paymentId, smsPhones);
+            break; // Only send highest threshold
+          }
+        }
+      }
+
+      // Check period expiring (3 days)
+      const daysLeft = (payment.period_end.getTime() - now.getTime()) / (1000 * 60 * 60 * 24);
+      if (daysLeft <= 3 && daysLeft > 0) {
+        // Only alert if no future payment exists
+        const futurePayment = await Payment.findOne({
+          tenant_id: payment.tenant_id,
+          type: 'subscription',
+          period_start: { $gt: payment.period_end },
+        });
+
+        if (!futurePayment) {
+          await sendAlertIfNew(tenantId, 'period_expiring', 'billing_period', paymentId, smsPhones);
+        }
+      }
+    } catch (err) {
+      logger.error('Billing alert check failed for tenant', {
+        tenantId: payment.tenant_id,
+        error: (err as Error).message,
+      });
+    }
+  }
+}
+
+async function sendAlertIfNew(
+  tenantId: string,
+  alertType: AlertType,
+  service: AlertService,
+  paymentId: string,
+  phones: string[],
+): Promise<void> {
+  // Check if already sent
+  const existing = await BillingAlert.findOne({
+    tenant_id: tenantId,
+    alert_type: alertType,
+    service,
+    payment_id: paymentId,
+  });
+  if (existing) return;
+
+  // Send SMS
+  const message = ALERT_MESSAGES[alertType];
+  const result = await netgsmService.sendSms(phones, message);
+
+  // Record alert (even if SMS fails, to prevent retries)
+  await BillingAlert.create({
+    tenant_id: tenantId,
+    alert_type: alertType,
+    service,
+    payment_id: paymentId,
+  });
+
+  logger.info('Billing alert sent', {
+    tenantId,
+    alertType,
+    service,
+    phones,
+    smsSuccess: result.success,
+  });
+}

package/src/modules/billing/payment.model.ts

@@ -0,0 +1,42 @@
+import mongoose, { Document, Schema } from 'mongoose';
+
+export type PaymentMethod = 'cash' | 'bank_transfer' | 'other';
+export type PaymentType = 'subscription' | 'top_up';
+
+export interface IPayment extends Document {
+  tenant_id: mongoose.Types.ObjectId;
+  type: PaymentType;
+  plan_slug: string;
+  plan_name: string;
+  amount: number;
+  extra_minutes: number;
+  period_start: Date;
+  period_end: Date;
+  payment_method: PaymentMethod;
+  notes: string;
+  recorded_by: mongoose.Types.ObjectId;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+const paymentSchema = new Schema<IPayment>({
+  tenant_id: { type: Schema.Types.ObjectId, ref: 'Tenant', required: true, index: true },
+  type: { type: String, enum: ['subscription', 'top_up'], default: 'subscription' },
+  plan_slug: { type: String, required: true },
+  plan_name: { type: String, required: true },
+  amount: { type: Number, required: true },
+  extra_minutes: { type: Number, default: 0 },
+  period_start: { type: Date, required: true },
+  period_end: { type: Date, required: true },
+  payment_method: {
+    type: String,
+    enum: ['cash', 'bank_transfer', 'other'],
+    default: 'cash'
+  },
+  notes: { type: String, default: '' },
+  recorded_by: { type: Schema.Types.ObjectId, ref: 'User', required: true }
+}, {
+  timestamps: true
+});
+
+export default mongoose.model<IPayment>('Payment', paymentSchema);

package/src/modules/calls/call.model.ts

@@ -0,0 +1,102 @@
+import mongoose, { Document, Schema } from 'mongoose';
+
+export type CallDirection = 'inbound' | 'outbound';
+export type CallStatus = 'completed' | 'failed' | 'no_answer' | 'voicemail' | 'transferred';
+
+export interface ISurveyResponse {
+  question_id: string;
+  question_text: string;
+  answer: string;
+  parsed_value: unknown;
+}
+
+export interface ICall extends Document {
+  tenant_id: mongoose.Types.ObjectId;
+  agent_id: mongoose.Types.ObjectId;
+  campaign_id: mongoose.Types.ObjectId | null;
+  conversation_id: string;
+  direction: CallDirection;
+  caller_number: string;
+  callee_number: string;
+  duration_seconds: number;
+  start_time: Date | null;
+  end_time: Date | null;
+  termination_reason: string | null;
+  cost: number | null;
+  call_language: string | null;
+  elevenlabs_status: string | null;
+  status: CallStatus;
+  transcript: string;
+  llm_summary: string | null;
+  sentiment: 'positive' | 'neutral' | 'negative' | null;
+  categories: string[];
+  survey_responses: ISurveyResponse[] | null;
+  whatsapp_notification_sent: boolean;
+  recording_url: string | null;
+  analysis: Record<string, unknown> | null;
+  createdAt: Date;
+}
+
+const surveyResponseSchema = new Schema<ISurveyResponse>({
+  question_id: { type: String, required: true },
+  question_text: { type: String, required: true },
+  answer: { type: String, default: '' },
+  parsed_value: { type: Schema.Types.Mixed }
+}, { _id: false });
+
+const callSchema = new Schema<ICall>({
+  tenant_id: {
+    type: Schema.Types.ObjectId,
+    ref: 'Tenant',
+    required: true
+  },
+  agent_id: {
+    type: Schema.Types.ObjectId,
+    ref: 'Agent',
+    required: true
+  },
+  campaign_id: {
+    type: Schema.Types.ObjectId,
+    ref: 'Campaign',
+    default: null
+  },
+  conversation_id: { type: String, default: null, index: true },
+  direction: {
+    type: String,
+    enum: ['inbound', 'outbound'],
+    required: true
+  },
+  caller_number: { type: String, required: true },
+  callee_number: { type: String, required: true },
+  duration_seconds: { type: Number, default: 0 },
+  start_time: { type: Date, default: null },
+  end_time: { type: Date, default: null },
+  termination_reason: { type: String, default: null },
+  cost: { type: Number, default: null },
+  call_language: { type: String, default: null },
+  elevenlabs_status: { type: String, default: null },
+  status: {
+    type: String,
+    enum: ['completed', 'failed', 'no_answer', 'voicemail', 'transferred'],
+    required: true
+  },
+  transcript: { type: String, default: '' },
+  llm_summary: { type: String, default: null },
+  sentiment: { type: String, enum: ['positive', 'neutral', 'negative', null], default: null },
+  categories: { type: [String], default: [] },
+  survey_responses: {
+    type: [surveyResponseSchema],
+    default: null
+  },
+  whatsapp_notification_sent: { type: Boolean, default: false },
+  recording_url: { type: String, default: null },
+  analysis: { type: Schema.Types.Mixed, default: null }
+}, {
+  timestamps: { createdAt: true, updatedAt: false }
+});
+
+callSchema.index({ tenant_id: 1, createdAt: -1 });
+callSchema.index({ campaign_id: 1, status: 1 });
+callSchema.index({ tenant_id: 1, direction: 1, createdAt: -1 });
+
+export default mongoose.model<ICall>('Call', callSchema);