elevenlabs-webhook-nodejs 1.0.0

package/src/modules/admin/admin.routes.ts

@@ -0,0 +1,2385 @@
+import mongoose from 'mongoose';
+import { FastifyInstance } from 'fastify';
+import Tenant, { AVAILABLE_FEATURES } from '../tenants/tenant.model';
+import User from '../auth/auth.model';
+import Agent from '../agents/agent.model';
+import Call from '../calls/call.model';
+import Campaign from '../campaigns/campaign.model';
+import BillingEvent from '../billing/billing.model';
+import { requireRole } from '../../plugins/rbac';
+import { hashPassword } from '../auth/auth.service';
+import Plan from '../plans/plan.model';
+import Payment from '../billing/payment.model';
+import elevenlabsService from '../../services/elevenlabs.service';
+import { snapshotPeriod } from '../billing/billing.service';
+import logger from '../../utils/logger';
+import elevenlabsTestChatRoutes from './elevenlabs-test-chat.routes';
+import whatsappTestChatRoutes from './whatsapp-test-chat.routes';
+import migrationRoutes from '../../migrations/migration.routes';
+import WhatsAppSession from '../whatsapp/whatsapp-session.model';
+import WhatsAppMessage from '../whatsapp/whatsapp-message.model';
+import WhatsAppChat from '../whatsapp/whatsapp-chat.model';
+import WhatsAppContactProfile from '../whatsapp/whatsapp-contact-profile.model';
+import whatsappAgentService from '../../services/whatsapp-agent.service';
+import Lead from '../leads/lead.model';
+import ConversationEvaluation from '../../models/ConversationEvaluation';
+import ConversationClaim from '../../models/ConversationClaim';
+import { Readable } from 'stream';
+
+export default async function superAdminRoutes(fastify: FastifyInstance): Promise<void> {
+  fastify.addHook('preHandler', fastify.authenticate);
+  fastify.addHook('preHandler', requireRole('superadmin'));
+
+  // Register sub-routes
+  await fastify.register(elevenlabsTestChatRoutes, { prefix: '/elevenlabs/test-chat' });
+  await fastify.register(whatsappTestChatRoutes, { prefix: '/whatsapp/test-chat' });
+  await fastify.register(migrationRoutes, { prefix: '/migrations' });
+
+  // ─── Tenants ────────────────────────────────────────────────
+
+  // GET /admin/tenants — list all tenants with user count
+  fastify.get<{
+    Querystring: { page?: string; search?: string };
+  }>('/tenants', async (request) => {
+    const page = parseInt(request.query.page || '1', 10);
+    const limit = 20;
+    const skip = (page - 1) * limit;
+
+    const filter: Record<string, unknown> = { $or: [{ is_active: true }, { is_active: { $exists: false } }] };
+    if (request.query.search) {
+      filter.name = { $regex: request.query.search, $options: 'i' };
+    }
+
+    const [tenants, total] = await Promise.all([
+      Tenant.find(filter).sort({ createdAt: -1 }).skip(skip).limit(limit).lean(),
+      Tenant.countDocuments(filter)
+    ]);
+
+    // Attach user count per tenant
+    const tenantIds = tenants.map(t => t._id);
+    const userCounts = await User.aggregate([
+      { $match: { tenant_id: { $in: tenantIds } } },
+      { $group: { _id: '$tenant_id', count: { $sum: 1 } } }
+    ]);
+    const userCountMap = new Map(userCounts.map(u => [String(u._id), u.count]));
+
+    const enriched = tenants.map(t => ({
+      ...t,
+      user_count: userCountMap.get(String(t._id)) || 0
+    }));
+
+    return { tenants: enriched, total, page, totalPages: Math.ceil(total / limit) };
+  });
+
+  // POST /admin/tenants — create tenant manually
+  fastify.post('/tenants', async (request, reply) => {
+    const { name, plan, enabled_features } = request.body as {
+      name: string;
+      plan?: string;
+      enabled_features?: string[];
+    };
+
+    if (!name) {
+      return reply.status(400).send({ error: 'name is required' });
+    }
+
+    const tenant = await Tenant.create({
+      name,
+      plan: plan || 'free',
+      enabled_features: enabled_features || [],
+      settings: { kvkk_consent: false, notification_recipients: [], default_language: 'tr' }
+    });
+
+    return reply.status(201).send({ tenant });
+  });
+
+  // GET /admin/tenants/:id — full tenant detail
+  fastify.get('/tenants/:id', async (request, reply) => {
+    const { id } = request.params as { id: string };
+    const tenant = await Tenant.findById(id).lean();
+    if (!tenant) {
+      return reply.status(404).send({ error: 'Tenant not found' });
+    }
+
+    const [users, agents, callCount, campaignCount] = await Promise.all([
+      User.find({ tenant_id: id }).select('name email role createdAt').lean(),
+      Agent.find({ tenant_id: id }).lean(),
+      Call.countDocuments({ tenant_id: id }),
+      Campaign.countDocuments({ tenant_id: id })
+    ]);
+
+    return { tenant, users, agents, callCount, campaignCount };
+  });
+
+  // PUT /admin/tenants/:id — update tenant
+  fastify.put('/tenants/:id', async (request, reply) => {
+    const { id } = request.params as { id: string };
+    const { name, plan, enabled_features, settings } = request.body as {
+      name?: string;
+      plan?: string;
+      enabled_features?: string[];
+      settings?: Record<string, unknown>;
+    };
+
+    const tenant = await Tenant.findById(id);
+    if (!tenant) {
+      return reply.status(404).send({ error: 'Tenant not found' });
+    }
+
+    if (name) tenant.name = name;
+    if (plan) tenant.plan = plan;
+    if (enabled_features) {
+      tenant.enabled_features = enabled_features.filter(
+        f => (AVAILABLE_FEATURES as readonly string[]).includes(f)
+      ) as typeof tenant.enabled_features;
+    }
+    if (settings) {
+      const { whatsapp_agent, ...rest } = settings as Record<string, unknown>;
+      Object.assign(tenant.settings, rest);
+      if (whatsapp_agent && typeof whatsapp_agent === 'object') {
+        Object.assign(tenant.settings.whatsapp_agent, whatsapp_agent);
+      }
+    }
+
+    await tenant.save();
+    return { tenant };
+  });
+
+  // PUT /admin/tenants/:id/features — toggle features
+  fastify.put('/tenants/:id/features', async (request, reply) => {
+    const { id } = request.params as { id: string };
+    const { enabled_features } = request.body as { enabled_features: string[] };
+
+    const tenant = await Tenant.findById(id);
+    if (!tenant) {
+      return reply.status(404).send({ error: 'Tenant not found' });
+    }
+
+    tenant.enabled_features = enabled_features.filter(
+      f => (AVAILABLE_FEATURES as readonly string[]).includes(f)
+    ) as typeof tenant.enabled_features;
+
+    await tenant.save();
+    return { tenant };
+  });
+
+  // PUT /admin/tenants/:id/deactivate — soft delete (deactivate tenant)
+  fastify.put('/tenants/:id/deactivate', async (request, reply) => {
+    const { id } = request.params as { id: string };
+    const tenant = await Tenant.findById(id);
+    if (!tenant) return reply.status(404).send({ error: 'Tenant not found' });
+
+    tenant.is_active = false;
+    tenant.deleted_at = new Date();
+    await tenant.save();
+
+    logger.info('Tenant deactivated (soft delete)', { tenantId: id, name: tenant.name });
+    return { tenant };
+  });
+
+  // PUT /admin/tenants/:id/reactivate — undo soft delete
+  fastify.put('/tenants/:id/reactivate', async (request, reply) => {
+    const { id } = request.params as { id: string };
+    const tenant = await Tenant.findById(id);
+    if (!tenant) return reply.status(404).send({ error: 'Tenant not found' });
+
+    tenant.is_active = true;
+    tenant.deleted_at = null;
+    await tenant.save();
+
+    logger.info('Tenant reactivated', { tenantId: id, name: tenant.name });
+    return { tenant };
+  });
+
+  // DELETE /admin/tenants/:id — hard delete (tombstones data, mangles unique fields)
+  fastify.delete('/tenants/:id', async (request, reply) => {
+    const { id } = request.params as { id: string };
+    const tenant = await Tenant.findById(id);
+    if (!tenant) return reply.status(404).send({ error: 'Tenant not found' });
+
+    if (tenant.is_active) {
+      return reply.status(400).send({ error: 'Tenant must be deactivated before permanent deletion' });
+    }
+
+    const suffix = `___deleted_${Date.now()}`;
+    const tenantOid = new mongoose.Types.ObjectId(id);
+
+    // Mangle unique fields to avoid conflicts, mark as deleted
+    await Promise.all([
+      // Mangle user emails so they can re-register
+      User.updateMany(
+        { tenant_id: tenantOid },
+        [{ $set: { email: { $concat: ['$email', suffix] }, is_active: false } }],
+      ),
+      // Deactivate agents
+      Agent.updateMany(
+        { tenant_id: tenantOid },
+        { $set: { is_active: false } },
+      ),
+      // Mangle tenant name
+      Tenant.updateOne(
+        { _id: tenantOid },
+        { $set: { name: `${tenant.name}${suffix}`, is_active: false, deleted_at: new Date() } },
+      ),
+    ]);
+
+    logger.info('Tenant hard deleted (tombstoned)', { tenantId: id, name: tenant.name, suffix });
+    return { deleted: true };
+  });
+
+  // ─── User Creation for Tenant ──────────────────────────────
+
+  // POST /admin/tenants/:id/users — create user for a tenant
+  fastify.post('/tenants/:id/users', async (request, reply) => {
+    const { id } = request.params as { id: string };
+    const { email, password, name, role } = request.body as {
+      email: string;
+      password: string;
+      name: string;
+      role?: string;
+    };
+
+    if (!email || !password || !name) {
+      return reply.status(400).send({ error: 'email, password, and name are required' });
+    }
+
+    const tenant = await Tenant.findById(id);
+    if (!tenant) {
+      return reply.status(404).send({ error: 'Tenant not found' });
+    }
+
+    const existing = await User.findOne({ email: email.toLowerCase() });
+    if (existing) {
+      return reply.status(409).send({ error: 'Bu e-posta zaten kullaniliyor' });
+    }
+
+    const password_hash = await hashPassword(password);
+    const user = await User.create({
+      tenant_id: id,
+      email: email.toLowerCase(),
+      password_hash,
+      name,
+      role: role || 'admin'
+    });
+
+    return reply.status(201).send({
+      user: { _id: user._id, name: user.name, email: user.email, role: user.role, createdAt: user.createdAt }
+    });
+  });
+
+  // ─── Agent Provisioning ─────────────────────────────────────
+
+  // GET /admin/elevenlabs/available-agents — EL agents not yet assigned to any tenant
+  fastify.get('/elevenlabs/available-agents', async () => {
+    // Get all ElevenLabs agents
+    const elAgents = await elevenlabsService.listAgents({ pageSize: 100 });
+    // Get all already-assigned ElevenLabs agent IDs
+    const assignedIds = await Agent.distinct('elevenlabs_agent_id');
+    const assignedSet = new Set(assignedIds as string[]);
+
+    const available = elAgents.agents
+      .filter(a => !assignedSet.has(a.agentId))
+      .map(a => ({
+        agent_id: a.agentId,
+        name: a.name,
+      }));
+
+    return { agents: available };
+  });
+
+  // POST /admin/agents — provision agent for a tenant
+  fastify.post('/agents', async (request, reply) => {
+    const {
+      tenant_id, phone_number, elevenlabs_agent_id, direction,
+      post_call_processing
+    } = request.body as {
+      tenant_id: string;
+      phone_number: string;
+      elevenlabs_agent_id: string;
+      direction?: string;
+      post_call_processing?: Record<string, unknown>;
+    };
+
+    if (!tenant_id || !phone_number || !elevenlabs_agent_id) {
+      return reply.status(400).send({
+        error: 'tenant_id, phone_number, and elevenlabs_agent_id are required'
+      });
+    }
+
+    const tenant = await Tenant.findById(tenant_id);
+    if (!tenant) {
+      return reply.status(404).send({ error: 'Tenant not found' });
+    }
+
+    // Prevent duplicate assignment within the same tenant
+    const existing = await Agent.findOne({ elevenlabs_agent_id, tenant_id });
+    if (existing) {
+      return reply.status(409).send({ error: 'Bu ElevenLabs agent zaten bu tenanta atanmis' });
+    }
+
+    const agent = await Agent.create({
+      tenant_id,
+      phone_number,
+      elevenlabs_agent_id,
+      direction: direction && ['inbound', 'outbound', 'both'].includes(direction) ? direction : 'inbound',
+      agent_template: 'custom',
+      config: {
+        voice_id: 'default',
+        language: 'tr',
+        greeting: '',
+        template_data: {}
+      },
+      post_call_processing: {
+        strategy: 'summarize',
+        llm_provider: (post_call_processing?.llm_provider as string) || 'openai',
+        whatsapp_notify: true,
+        notification_template: 'call_summary',
+        summary_prompt: (post_call_processing?.summary_prompt as string) || '',
+        system_message: '',
+        whatsapp_message_template: (post_call_processing?.whatsapp_message_template as string) || ''
+      },
+      is_active: true
+    });
+
+    return reply.status(201).send({ agent });
+  });
+
+  // PUT /admin/agents/:id — update agent (superadmin)
+  fastify.put('/agents/:id', async (request, reply) => {
+    const { id } = request.params as { id: string };
+    const { phone_number, direction, is_active, post_call_processing } = request.body as {
+      phone_number?: string;
+      direction?: string;
+      is_active?: boolean;
+      post_call_processing?: { summary_prompt?: string; whatsapp_message_template?: string };
+    };
+
+    const agent = await Agent.findById(id);
+    if (!agent) {
+      return reply.status(404).send({ error: 'Agent not found' });
+    }
+
+    if (phone_number !== undefined) agent.phone_number = phone_number;
+    if (direction && ['inbound', 'outbound', 'both'].includes(direction)) agent.direction = direction as any;
+    if (is_active !== undefined) agent.is_active = is_active;
+    if (post_call_processing) {
+      if (post_call_processing.summary_prompt !== undefined) {
+        agent.post_call_processing.summary_prompt = post_call_processing.summary_prompt;
+      }
+      if (post_call_processing.whatsapp_message_template !== undefined) {
+        agent.post_call_processing.whatsapp_message_template = post_call_processing.whatsapp_message_template;
+      }
+    }
+
+    await agent.save();
+    return { agent };
+  });
+
+  // ─── System Health ──────────────────────────────────────────
+
+  // GET /admin/system/health
+  fastify.get('/system/health', async () => {
+    const now = new Date();
+    const todayStart = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+    const monthStart = new Date(now.getFullYear(), now.getMonth(), 1);
+    const sevenDaysAgo = new Date(now);
+    sevenDaysAgo.setDate(sevenDaysAgo.getDate() - 6);
+    sevenDaysAgo.setHours(0, 0, 0, 0);
+
+    const [
+      tenantCount,
+      userCount,
+      agentCount,
+      totalCalls,
+      todayCalls,
+      activeCampaigns,
+      monthlyRevenue,
+      callStatusRows,
+      dailyTrendRows
+    ] = await Promise.all([
+      Tenant.countDocuments(),
+      User.countDocuments(),
+      Agent.countDocuments(),
+      Call.countDocuments(),
+      Call.countDocuments({ createdAt: { $gte: todayStart } }),
+      Campaign.countDocuments({ status: { $in: ['running', 'scheduled'] } }),
+      BillingEvent.aggregate([
+        { $match: { type: 'call_charge', createdAt: { $gte: monthStart } } },
+        { $group: { _id: null, total: { $sum: '$amount' } } }
+      ]).then(r => r[0]?.total || 0),
+      // Call status breakdown this month
+      Call.aggregate([
+        { $match: { createdAt: { $gte: monthStart } } },
+        { $group: { _id: '$status', count: { $sum: 1 } } }
+      ]),
+      // Daily trend last 7 days
+      Call.aggregate([
+        { $match: { createdAt: { $gte: sevenDaysAgo } } },
+        { $group: { _id: { $dateToString: { format: '%Y-%m-%d', date: '$createdAt' } }, count: { $sum: 1 } } },
+        { $sort: { _id: 1 } }
+      ])
+    ]);
+
+    // Build status breakdown map
+    const callStatusBreakdown: Record<string, number> = { completed: 0, failed: 0, no_answer: 0, voicemail: 0, transferred: 0 };
+    callStatusRows.forEach((r: { _id: string; count: number }) => { callStatusBreakdown[r._id] = r.count; });
+
+    // Fill 7-day trend with zeros for missing days
+    const dailyTrend: { date: string; count: number }[] = [];
+    for (let i = 6; i >= 0; i--) {
+      const d = new Date(now);
+      d.setDate(d.getDate() - i);
+      const key = d.toISOString().slice(0, 10);
+      const found = dailyTrendRows.find((r: { _id: string }) => r._id === key);
+      dailyTrend.push({ date: key, count: found?.count || 0 });
+    }
+
+    return {
+      status: 'ok',
+      uptime: process.uptime(),
+      stats: {
+        tenants: tenantCount,
+        users: userCount,
+        agents: agentCount,
+        total_calls: totalCalls,
+        today_calls: todayCalls,
+        active_campaigns: activeCampaigns,
+        monthly_revenue: monthlyRevenue
+      },
+      call_status_breakdown: callStatusBreakdown,
+      daily_trend: dailyTrend,
+      system: {
+        memory: process.memoryUsage(),
+        node_version: process.version,
+        db_state: mongoose.connection.readyState
+      }
+    };
+  });
+
+  // GET /admin/system/usage — global usage per tenant with quota info
+  fastify.get('/system/usage', async () => {
+    const monthStart = new Date();
+    monthStart.setDate(1);
+    monthStart.setHours(0, 0, 0, 0);
+    const now = new Date();
+
+    const [usagePerTenant, allPlans, activeTopUps] = await Promise.all([
+      Call.aggregate([
+        { $match: { createdAt: { $gte: monthStart } } },
+        {
+          $group: {
+            _id: '$tenant_id',
+            calls: { $sum: 1 },
+            duration: { $sum: '$duration_seconds' },
+            completed: { $sum: { $cond: [{ $eq: ['$status', 'completed'] }, 1, 0] } },
+            failed: { $sum: { $cond: [{ $eq: ['$status', 'failed'] }, 1, 0] } },
+            no_answer: { $sum: { $cond: [{ $eq: ['$status', 'no_answer'] }, 1, 0] } }
+          }
+        },
+        {
+          $lookup: {
+            from: 'tenants',
+            localField: '_id',
+            foreignField: '_id',
+            as: 'tenant'
+          }
+        },
+        { $unwind: '$tenant' },
+        {
+          $project: {
+            tenant_id: '$_id',
+            tenant_name: '$tenant.name',
+            plan: '$tenant.plan',
+            calls: 1,
+            duration: 1,
+            completed: 1,
+            failed: 1,
+            no_answer: 1
+          }
+        },
+        { $sort: { calls: -1 } }
+      ]),
+      Plan.find().lean(),
+      Payment.aggregate([
+        {
+          $match: {
+            type: 'top_up',
+            period_start: { $lte: now },
+            period_end: { $gte: monthStart }
+          }
+        },
+        { $group: { _id: '$tenant_id', extra_minutes: { $sum: '$extra_minutes' } } }
+      ])
+    ]);
+
+    const planMap = new Map(allPlans.map(p => [p.slug, p.included_minutes]));
+    const topUpMap = new Map(activeTopUps.map((t: { _id: mongoose.Types.ObjectId; extra_minutes: number }) => [String(t._id), t.extra_minutes]));
+
+    const enriched = usagePerTenant.map((u: any) => {
+      const planMinutes = planMap.get(u.plan) || 0;
+      const topUpMinutes = topUpMap.get(String(u.tenant_id)) || 0;
+      const totalQuota = planMinutes + topUpMinutes;
+      const usedMinutes = Math.ceil(u.duration / 60);
+      const pct = totalQuota > 0 ? Math.round((usedMinutes / totalQuota) * 100) : 0;
+
+      return {
+        ...u,
+        plan_minutes: planMinutes,
+        top_up_minutes: topUpMinutes,
+        total_quota: totalQuota,
+        used_minutes: usedMinutes,
+        quota_percentage: Math.min(pct, 100),
+        over_quota: usedMinutes > totalQuota
+      };
+    });
+
+    return { usage: enriched };
+  });
+
+  // GET /admin/templates — list agent templates
+  fastify.get('/templates', async () => {
+    return {
+      templates: [
+        { name: 'receptionist', direction: 'inbound', description: 'AI resepsiyonist — cagri karsilama, SSS, randevu' },
+        { name: 'survey', direction: 'outbound', description: 'AI anketci — yapilandirilmis soru-cevap' },
+        { name: 'custom', direction: 'both', description: 'Ozel prompt — tenant kendi promptunu yazar' }
+      ]
+    };
+  });
+
+  // ─── Plans ─────────────────────────────────────────────────
+
+  // GET /admin/plans — list all plans
+  fastify.get('/plans', async () => {
+    const plans = await Plan.find().sort({ sort_order: 1 }).lean();
+    return { plans };
+  });
+
+  // POST /admin/plans — create plan
+  fastify.post('/plans', async (request, reply) => {
+    const { name, slug, price, included_minutes, overage_rate, language_support, sort_order,
+      included_inbound_minutes, included_inbound_calls, included_outbound_minutes, included_outbound_calls, included_wa_chats,
+    } = request.body as {
+      name: string;
+      slug: string;
+      price: number;
+      included_minutes: number;
+      overage_rate: number;
+      language_support?: string;
+      sort_order?: number;
+      included_inbound_minutes?: number;
+      included_inbound_calls?: number;
+      included_outbound_minutes?: number;
+      included_outbound_calls?: number;
+      included_wa_chats?: number;
+    };
+
+    if (!name || !slug || price == null || included_minutes == null || overage_rate == null) {
+      return reply.status(400).send({ error: 'name, slug, price, included_minutes, overage_rate are required' });
+    }
+
+    const existing = await Plan.findOne({ slug });
+    if (existing) {
+      return reply.status(409).send({ error: 'Bu slug zaten kullaniliyor' });
+    }
+
+    const plan = await Plan.create({
+      name, slug, price, included_minutes, overage_rate,
+      included_inbound_minutes: included_inbound_minutes ?? 0,
+      included_inbound_calls: included_inbound_calls ?? 0,
+      included_outbound_minutes: included_outbound_minutes ?? 0,
+      included_outbound_calls: included_outbound_calls ?? 0,
+      included_wa_chats: included_wa_chats ?? 0,
+      language_support: language_support || 'single',
+      sort_order: sort_order ?? 0
+    });
+
+    return reply.status(201).send({ plan });
+  });
+
+  // PUT /admin/plans/:id — update plan
+  fastify.put('/plans/:id', async (request, reply) => {
+    const { id } = request.params as { id: string };
+    const updates = request.body as Record<string, unknown>;
+
+    const plan = await Plan.findById(id);
+    if (!plan) {
+      return reply.status(404).send({ error: 'Plan not found' });
+    }
+
+    const allowed = ['name', 'slug', 'price', 'included_minutes', 'overage_rate', 'included_inbound_minutes', 'included_inbound_calls', 'included_outbound_minutes', 'included_outbound_calls', 'included_wa_chats', 'language_support', 'is_active', 'sort_order'];
+    for (const key of allowed) {
+      if (updates[key] !== undefined) {
+        (plan as any)[key] = updates[key];
+      }
+    }
+
+    await plan.save();
+    return { plan };
+  });
+
+  // POST /admin/plans/seed — seed default plans
+  fastify.post('/plans/seed', async (request, reply) => {
+    const count = await Plan.countDocuments();
+    if (count > 0) {
+      return reply.status(409).send({ error: 'Planlar zaten mevcut', count });
+    }
+
+    const defaults = [
+      { name: 'Ucretsiz', slug: 'free', price: 0, included_minutes: 30, overage_rate: 0, language_support: 'single', sort_order: 0 },
+      { name: 'Mini Paket', slug: 'mini', price: 2999, included_minutes: 100, overage_rate: 34.99, language_support: 'single', sort_order: 1 },
+      { name: 'Standart Paket', slug: 'standart', price: 4999, included_minutes: 200, overage_rate: 29.99, language_support: 'single', sort_order: 2 },
+      { name: 'Pro Paket', slug: 'pro', price: 6999, included_minutes: 300, overage_rate: 24.99, language_support: 'dual', sort_order: 3 },
+      { name: 'Pro Max Paket', slug: 'pro-max', price: 9999, included_minutes: 500, overage_rate: 19.99, language_support: 'multi', sort_order: 4 },
+    ];
+
+    const plans = await Plan.insertMany(defaults);
+    return reply.status(201).send({ plans });
+  });
+
+  // ─── Payments ───────────────────────────────────────────────
+
+  // GET /admin/payments — list all payments (filterable by tenant_id)
+  fastify.get<{
+    Querystring: { page?: string; tenant_id?: string };
+  }>('/payments', async (request) => {
+    const page = parseInt(request.query.page || '1', 10);
+    const limit = 20;
+    const skip = (page - 1) * limit;
+
+    const filter: Record<string, unknown> = {};
+    if (request.query.tenant_id) {
+      filter.tenant_id = request.query.tenant_id;
+    }
+
+    const [payments, total] = await Promise.all([
+      Payment.find(filter).sort({ period_start: -1 }).skip(skip).limit(limit).lean(),
+      Payment.countDocuments(filter)
+    ]);
+
+    return { payments, total, page, totalPages: Math.ceil(total / limit) };
+  });
+
+  // GET /admin/tenants/:id/payments — payments for a specific tenant
+  fastify.get('/tenants/:id/payments', async (request) => {
+    const { id } = request.params as { id: string };
+    const payments = await Payment.find({ tenant_id: id }).sort({ period_start: -1 }).lean();
+    return { payments };
+  });
+
+  // GET /admin/tenants/:id/billable-items — calls & AI WhatsApp sessions as billable objects
+  fastify.get<{
+    Params: { id: string };
+    Querystring: { page_calls?: string; page_chats?: string; page_sessions?: string; from?: string; to?: string };
+  }>('/tenants/:id/billable-items', async (request, reply) => {
+    const { id } = request.params;
+
+    const tenant = await Tenant.findById(id).lean();
+    if (!tenant) {
+      return reply.status(404).send({ error: 'Tenant not found' });
+    }
+
+    const pageCalls = Math.max(1, parseInt(request.query.page_calls || '1', 10));
+    const pageChats = Math.max(1, parseInt(request.query.page_chats || (request.query as Record<string, string>).page_sessions || '1', 10));
+    const limit = 20;
+    const skipCalls = (pageCalls - 1) * limit;
+    const skipChats = (pageChats - 1) * limit;
+
+    const now = new Date();
+    const monthStart = new Date(now.getFullYear(), now.getMonth(), 1);
+    const from = request.query.from ? new Date(request.query.from) : monthStart;
+    const to = request.query.to ? new Date(request.query.to) : now;
+
+    if (isNaN(from.getTime()) || isNaN(to.getTime())) {
+      return reply.status(400).send({ error: 'Invalid date format for from/to' });
+    }
+
+    const tenantOid = new mongoose.Types.ObjectId(id);
+
+    const [callItems, callSummaryRows, sessionResult] = await Promise.all([
+      // Q1: Paginated calls
+      Call.find({ tenant_id: id, createdAt: { $gte: from, $lte: to } })
+        .select('direction caller_number callee_number duration_seconds status cost createdAt agent_id conversation_id')
+        .sort({ createdAt: -1 })
+        .skip(skipCalls)
+        .limit(limit)
+        .lean(),
+
+      // Q2: Call summary (count + status breakdown + total duration + EL cost)
+      Call.aggregate([
+        { $match: { tenant_id: tenantOid, createdAt: { $gte: from, $lte: to } } },
+        {
+          $group: {
+            _id: null,
+            total: { $sum: 1 },
+            total_duration: { $sum: '$duration_seconds' },
+            total_cost: { $sum: { $ifNull: ['$cost', 0] } },
+            completed: { $sum: { $cond: [{ $eq: ['$status', 'completed'] }, 1, 0] } },
+            failed: { $sum: { $cond: [{ $eq: ['$status', 'failed'] }, 1, 0] } },
+            no_answer: { $sum: { $cond: [{ $eq: ['$status', 'no_answer'] }, 1, 0] } },
+            voicemail: { $sum: { $cond: [{ $eq: ['$status', 'voicemail'] }, 1, 0] } },
+            transferred: { $sum: { $cond: [{ $eq: ['$status', 'transferred'] }, 1, 0] } },
+          },
+        },
+      ]),
+
+      // Q3: Billable WA chats (AI answered at least once in date range) + pagination
+      WhatsAppChat.aggregate([
+        { $match: { tenant_id: tenantOid } },
+        // Single messages lookup: count total, AI messages, and collect session_ids
+        {
+          $lookup: {
+            from: 'whatsappmessages',
+            let: { cid: '$_id' },
+            pipeline: [
+              { $match: { $expr: { $eq: ['$chat_id', '$$cid'] }, createdAt: { $gte: from, $lte: to } } },
+              {
+                $group: {
+                  _id: null,
+                  total: { $sum: 1 },
+                  ai_count: { $sum: { $cond: [{ $eq: ['$sender_name', 'AI'] }, 1, 0] } },
+                  session_ids: { $addToSet: '$session_id' },
+                },
+              },
+            ],
+            as: '_messages',
+          },
+        },
+        {
+          $addFields: {
+            ai_message_count: { $ifNull: [{ $arrayElemAt: ['$_messages.ai_count', 0] }, 0] },
+            period_message_count: { $ifNull: [{ $arrayElemAt: ['$_messages.total', 0] }, 0] },
+            _session_ids: { $ifNull: [{ $arrayElemAt: ['$_messages.session_ids', 0] }, []] },
+          },
+        },
+        { $match: { ai_message_count: { $gt: 0 } } },
+        // Lookup sessions by actual message activity (not started_at) for EL cost
+        {
+          $lookup: {
+            from: 'whatsappsessions',
+            let: { sids: '$_session_ids' },
+            pipeline: [
+              { $match: { $expr: { $in: ['$_id', '$$sids'] } } },
+              {
+                $group: {
+                  _id: null,
+                  count: { $sum: 1 },
+                  total_cost: { $sum: { $ifNull: ['$elevenlabs_cost', 0] } },
+                },
+              },
+            ],
+            as: '_sessions',
+          },
+        },
+        {
+          $addFields: {
+            session_count: { $ifNull: [{ $arrayElemAt: ['$_sessions.count', 0] }, 0] },
+            elevenlabs_cost: { $ifNull: [{ $arrayElemAt: ['$_sessions.total_cost', 0] }, 0] },
+          },
+        },
+        {
+          $project: {
+            contact_name: 1, contact_phone: 1,
+            ai_message_count: 1, period_message_count: 1,
+            session_count: 1, elevenlabs_cost: 1,
+            last_message_at: 1, createdAt: 1,
+          },
+        },
+        { $sort: { last_message_at: -1 } },
+        {
+          $facet: {
+            data: [{ $skip: skipChats }, { $limit: limit }],
+            count: [{ $count: 'total' }],
+            summary: [{
+              $group: {
+                _id: null,
+                total_messages: { $sum: '$period_message_count' },
+                total_ai_messages: { $sum: '$ai_message_count' },
+                total_elevenlabs_cost: { $sum: '$elevenlabs_cost' },
+                total_sessions: { $sum: '$session_count' },
+              },
+            }],
+          },
+        },
+      ]),
+    ]);
+
+    const cs = callSummaryRows[0] || {
+      total: 0, total_duration: 0, total_cost: 0,
+      completed: 0, failed: 0, no_answer: 0, voicemail: 0, transferred: 0,
+    };
+    const chatData = sessionResult[0]?.data || [];
+    const totalBillableChats = sessionResult[0]?.count?.[0]?.total || 0;
+    const ss = sessionResult[0]?.summary?.[0] || {
+      total_messages: 0, total_ai_messages: 0, total_elevenlabs_cost: 0, total_sessions: 0,
+    };
+
+    return {
+      summary: {
+        total_calls: cs.total,
+        total_call_duration_seconds: cs.total_duration,
+        total_elevenlabs_cost: cs.total_cost,
+        calls_by_status: {
+          completed: cs.completed,
+          failed: cs.failed,
+          no_answer: cs.no_answer,
+          voicemail: cs.voicemail,
+          transferred: cs.transferred,
+        },
+        total_billable_chats: totalBillableChats,
+        total_chat_sessions: ss.total_sessions,
+        total_chat_messages: ss.total_messages,
+        total_chat_ai_messages: ss.total_ai_messages,
+        total_chat_elevenlabs_cost: ss.total_elevenlabs_cost,
+        date_range: { from: from.toISOString(), to: to.toISOString() },
+      },
+      calls: {
+        items: callItems,
+        total: cs.total,
+        page: pageCalls,
+        totalPages: Math.ceil(cs.total / limit),
+      },
+      whatsapp_chats: {
+        items: chatData,
+        total: totalBillableChats,
+        page: pageChats,
+        totalPages: Math.ceil(totalBillableChats / limit),
+      },
+    };
+  });
+
+  // POST /admin/tenants/:id/sync-whatsapp-costs — fetch ElevenLabs credits for sessions missing cost
+  fastify.post<{ Params: { id: string } }>('/tenants/:id/sync-whatsapp-costs', async (request, reply) => {
+    const { id } = request.params;
+
+    const tenant = await Tenant.findById(id).lean();
+    if (!tenant) {
+      return reply.status(404).send({ error: 'Tenant not found' });
+    }
+
+    const sessions = await WhatsAppSession.find({
+      tenant_id: new mongoose.Types.ObjectId(id),
+      elevenlabs_conversation_id: { $ne: null },
+      elevenlabs_cost: null,
+    }).lean();
+
+    let updated = 0;
+    let failed = 0;
+    for (const session of sessions) {
+      try {
+        const conv = await elevenlabsService.getConversation(session.elevenlabs_conversation_id!);
+        const cost = (conv as unknown as { metadata?: { cost?: number } }).metadata?.cost;
+        if (cost != null) {
+          await WhatsAppSession.updateOne({ _id: session._id }, { elevenlabs_cost: cost });
+          updated++;
+        }
+      } catch (err) {
+        const status = (err as { statusCode?: number }).statusCode
+          || (err as { status?: number }).status;
+        if (status === 404) {
+          await WhatsAppSession.updateOne({ _id: session._id }, { elevenlabs_cost: 0 });
+          updated++;
+        } else {
+          failed++;
+        }
+      }
+    }
+
+    return { total: sessions.length, updated, failed };
+  });
+
+  // POST /admin/payments — record a new payment
+  fastify.post('/payments', async (request, reply) => {
+    const { tenant_id, type, plan_slug, amount, extra_minutes, period_start, period_end, payment_method, notes } = request.body as {
+      tenant_id: string;
+      type?: string;
+      plan_slug: string;
+      amount: number;
+      extra_minutes?: number;
+      period_start: string;
+      period_end: string;
+      payment_method?: string;
+      notes?: string;
+    };
+
+    if (!tenant_id || !plan_slug || amount == null || !period_start || !period_end) {
+      return reply.status(400).send({ error: 'tenant_id, plan_slug, amount, period_start, period_end are required' });
+    }
+
+    const paymentType = type === 'top_up' ? 'top_up' : 'subscription';
+    if (paymentType === 'top_up' && (!extra_minutes || extra_minutes <= 0)) {
+      return reply.status(400).send({ error: 'Ek dakika (extra_minutes) top-up icin zorunludur' });
+    }
+
+    const tenant = await Tenant.findById(tenant_id);
+    if (!tenant) {
+      return reply.status(404).send({ error: 'Tenant not found' });
+    }
+
+    // Lookup plan name from slug
+    const plan = await Plan.findOne({ slug: plan_slug }).lean();
+    const plan_name = paymentType === 'top_up'
+      ? `Ek Dakika (${extra_minutes} dk)`
+      : (plan?.name || plan_slug);
+
+    const user = request.user as { id: string };
+    const payment = await Payment.create({
+      tenant_id,
+      type: paymentType,
+      plan_slug,
+      plan_name,
+      amount,
+      extra_minutes: paymentType === 'top_up' ? (extra_minutes || 0) : 0,
+      period_start: new Date(period_start),
+      period_end: new Date(period_end),
+      payment_method: payment_method || 'cash',
+      notes: notes || '',
+      recorded_by: user.id
+    });
+
+    // Snapshot previous billing period (subscription only, if it's expired)
+    if (paymentType === 'subscription') {
+      const now = new Date();
+      const prevPayment = await Payment.findOne({
+        tenant_id,
+        type: 'subscription',
+        _id: { $ne: payment._id },
+        period_end: { $lt: now },
+      }).sort({ period_end: -1 }).lean();
+
+      if (prevPayment) {
+        snapshotPeriod(tenant_id, prevPayment.period_start, prevPayment.period_end, prevPayment._id.toString())
+          .catch(err => logger.error('Failed to snapshot billing period', { error: (err as Error).message }));
+      }
+    }
+
+    return reply.status(201).send({ payment });
+  });
+
+  // ─── ElevenLabs API (read-only proxies) ───────────────────
+
+  // GET /admin/elevenlabs/agents — list ElevenLabs agents
+  fastify.get<{
+    Querystring: { page_size?: string; search?: string; cursor?: string };
+  }>('/elevenlabs/agents', async (request) => {
+    const { page_size, search, cursor } = request.query;
+    return elevenlabsService.listAgents({
+      pageSize: page_size ? parseInt(page_size, 10) : undefined,
+      search: search || undefined,
+      cursor: cursor || undefined,
+    });
+  });
+
+  // GET /admin/elevenlabs/agents/:agentId — get single ElevenLabs agent
+  fastify.get<{
+    Params: { agentId: string };
+  }>('/elevenlabs/agents/:agentId', async (request) => {
+    const { agentId } = request.params;
+    return elevenlabsService.getAgent(agentId);
+  });
+
+  // GET /admin/elevenlabs/conversations — list conversations
+  fastify.get<{
+    Querystring: {
+      agent_id?: string;
+      page_size?: string;
+      cursor?: string;
+      call_successful?: string;
+      search?: string;
+    };
+  }>('/elevenlabs/conversations', async (request) => {
+    const { agent_id, page_size, cursor, call_successful, search } = request.query;
+    return elevenlabsService.listConversations({
+      agentId: agent_id || undefined,
+      pageSize: page_size ? parseInt(page_size, 10) : undefined,
+      cursor: cursor || undefined,
+      callSuccessful: call_successful as 'success' | 'failure' | 'unknown' | undefined,
+      search: search || undefined,
+    });
+  });
+
+  // GET /admin/elevenlabs/conversations/:conversationId — get conversation detail
+  fastify.get<{
+    Params: { conversationId: string };
+  }>('/elevenlabs/conversations/:conversationId', async (request) => {
+    const { conversationId } = request.params;
+    return elevenlabsService.getConversation(conversationId);
+  });
+
+  // GET /admin/elevenlabs/conversations/review — enriched list with evaluation status
+  fastify.get<{
+    Querystring: {
+      agent_id?: string;
+      page_size?: string;
+      cursor?: string;
+      call_successful?: string;
+    };
+  }>('/elevenlabs/conversations/review', async (request) => {
+    const { agent_id, page_size, cursor, call_successful } = request.query;
+    const currentUser = request.user as { id: string };
+
+    // Get all active claims by OTHER users (exclude our own claims)
+    const otherClaims = await ConversationClaim.find({
+      user_id: { $ne: currentUser.id },
+      expires_at: { $gt: new Date() },
+    }).lean();
+    const claimedByOthers = new Set(otherClaims.map((c) => c.conversation_id));
+
+    const targetSize = page_size ? parseInt(page_size, 10) : 10;
+    const results: any[] = [];
+    let currentCursor = cursor || undefined;
+    let hasMore = true;
+    let nextCursor: string | undefined;
+
+    // Keep fetching pages until we have enough non-text conversations or run out
+    while (results.length < targetSize && hasMore) {
+      const listResult = await elevenlabsService.listConversations({
+        agentId: agent_id || undefined,
+        pageSize: 25, // fetch in chunks of 25
+        cursor: currentCursor,
+        callSuccessful: call_successful as 'success' | 'failure' | 'unknown' | undefined,
+      });
+
+      hasMore = listResult.hasMore || false;
+      nextCursor = listResult.nextCursor;
+      currentCursor = listResult.nextCursor;
+
+      if (listResult.conversations.length === 0) break;
+
+      // Quick filter: skip text agents before expensive detail fetch
+      const nonText = listResult.conversations.filter(
+        (c) => !(c.agentName || '').toLowerCase().includes('text')
+      );
+
+      if (nonText.length === 0) continue;
+
+      const conversationIds = nonText.map((c) => c.conversationId);
+
+      // Skip already-evaluated and claimed-by-others conversations
+      const evaluations = await ConversationEvaluation.find({
+        conversation_id: { $in: conversationIds },
+      }).lean();
+      const evaluatedIds = new Set(evaluations.map((e) => e.conversation_id));
+      const unevaluated = nonText.filter((c) =>
+        !evaluatedIds.has(c.conversationId) &&
+        !claimedByOthers.has(c.conversationId)
+      );
+
+      if (unevaluated.length === 0) continue;
+
+      const enriched = await Promise.all(
+        unevaluated.map(async (c) => {
+          try {
+            const detail = await elevenlabsService.getConversation(c.conversationId);
+            const phoneCall = detail.metadata?.phoneCall;
+            return {
+              conversationId: c.conversationId,
+              agentId: c.agentId,
+              agentName: c.agentName,
+              status: c.status,
+              callSuccessful: c.callSuccessful,
+              callDurationSecs: c.callDurationSecs,
+              messageCount: c.messageCount,
+              direction: c.direction,
+              startTimeUnixSecs: c.startTimeUnixSecs,
+              transcriptSummary: c.transcriptSummary,
+              externalNumber: phoneCall ? (phoneCall as any).externalNumber : null,
+              agentNumber: phoneCall ? (phoneCall as any).agentNumber : null,
+              terminationReason: detail.metadata?.terminationReason || null,
+              cost: detail.metadata?.cost ?? null,
+              hasAudio: detail.hasAudio ?? false,
+              hasEvaluation: false,
+              evaluation: null,
+            };
+          } catch {
+            return {
+              conversationId: c.conversationId,
+              agentId: c.agentId,
+              agentName: c.agentName,
+              status: c.status,
+              callSuccessful: c.callSuccessful,
+              callDurationSecs: c.callDurationSecs,
+              messageCount: c.messageCount,
+              direction: c.direction,
+              startTimeUnixSecs: c.startTimeUnixSecs,
+              transcriptSummary: c.transcriptSummary,
+              externalNumber: null,
+              agentNumber: null,
+              terminationReason: null,
+              cost: null,
+              hasAudio: false,
+              hasEvaluation: false,
+              evaluation: null,
+            };
+          }
+        })
+      );
+
+      results.push(...enriched);
+    }
+
+    return {
+      conversations: results.slice(0, targetSize),
+      hasMore: hasMore || results.length > targetSize,
+      nextCursor,
+    };
+  });
+
+  // GET /admin/elevenlabs/conversations/:conversationId/audio — stream audio
+  fastify.get<{
+    Params: { conversationId: string };
+  }>('/elevenlabs/conversations/:conversationId/audio', async (request, reply) => {
+    const { conversationId } = request.params;
+    try {
+      const audioResult = await elevenlabsService.getConversationAudio(conversationId);
+
+      reply
+        .type('audio/mpeg')
+        .header('Cache-Control', 'public, max-age=86400')
+        .header('Accept-Ranges', 'bytes');
+
+      // Handle different return types from the SDK
+      if (audioResult instanceof ReadableStream) {
+        // Web ReadableStream → Node Readable
+        const nodeStream = Readable.fromWeb(audioResult as any);
+        return reply.send(nodeStream);
+      } else if (Buffer.isBuffer(audioResult)) {
+        return reply.send(audioResult);
+      } else if (audioResult && typeof (audioResult as any).pipe === 'function') {
+        // Already a Node.js Readable stream
+        return reply.send(audioResult);
+      } else if (audioResult && typeof (audioResult as any)[Symbol.asyncIterator] === 'function') {
+        // Async iterable
+        const chunks: Buffer[] = [];
+        for await (const chunk of audioResult as any) {
+          chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+        }
+        return reply.send(Buffer.concat(chunks));
+      } else {
+        // Fallback: try to send as-is
+        return reply.send(audioResult as any);
+      }
+    } catch (error) {
+      logger.error('Failed to stream conversation audio', { conversationId, error: (error as Error).message });
+      return reply.status(500).send({ error: 'Audio yuklenemedi' });
+    }
+  });
+
+  // GET /admin/elevenlabs/evaluations — list all evaluations with pagination
+  fastify.get<{
+    Querystring: {
+      page?: string;
+      limit?: string;
+      evaluator_id?: string;
+      skipped?: string;
+      min_score?: string;
+      max_score?: string;
+    };
+  }>('/elevenlabs/evaluations', async (request) => {
+    const { page = '1', limit = '20', evaluator_id, skipped, min_score, max_score } = request.query;
+    const pageNum = Math.max(1, parseInt(page, 10));
+    const limitNum = Math.min(100, Math.max(1, parseInt(limit, 10)));
+    const skip = (pageNum - 1) * limitNum;
+
+    const filter: Record<string, unknown> = {};
+    if (evaluator_id) filter.evaluator_id = evaluator_id;
+    if (skipped === 'true') filter.skipped = true;
+    if (skipped === 'false') filter.skipped = { $ne: true };
+    if (min_score) filter.overall_score = { ...((filter.overall_score as object) || {}), $gte: parseFloat(min_score) };
+    if (max_score) filter.overall_score = { ...((filter.overall_score as object) || {}), $lte: parseFloat(max_score) };
+
+    const [rawEvaluations, total] = await Promise.all([
+      ConversationEvaluation.find(filter).sort({ createdAt: -1 }).skip(skip).limit(limitNum).lean(),
+      ConversationEvaluation.countDocuments(filter),
+    ]);
+
+    // Enrich evaluations with conversation details from ElevenLabs
+    const evaluations = await Promise.all(
+      rawEvaluations.map(async (ev) => {
+        try {
+          const detail = await elevenlabsService.getConversation(ev.conversation_id);
+          const phoneCall = detail.metadata?.phoneCall;
+          return {
+            ...ev,
+            agentName: detail.agentName || null,
+            agentId: detail.agentId || null,
+            callDurationSecs: detail.metadata?.callDurationSecs || 0,
+            startTimeUnixSecs: detail.metadata?.startTimeUnixSecs || 0,
+            externalNumber: phoneCall ? (phoneCall as any).externalNumber : null,
+            cost: detail.metadata?.cost ?? null,
+            callSuccessful: detail.analysis?.callSuccessful || null,
+            transcriptSummary: detail.analysis?.transcriptSummary || null,
+          };
+        } catch {
+          return { ...ev, agentName: null, agentId: null, callDurationSecs: 0, startTimeUnixSecs: 0, externalNumber: null, cost: null, callSuccessful: null, transcriptSummary: null };
+        }
+      })
+    );
+
+    // Aggregate stats
+    const stats = await ConversationEvaluation.aggregate([
+      { $match: { skipped: { $ne: true } } },
+      {
+        $group: {
+          _id: null,
+          total: { $sum: 1 },
+          avg_score: { $avg: '$overall_score' },
+          avg_patient_audio: { $avg: '$patient_audio_quality' },
+          avg_ai_comprehension: { $avg: '$ai_comprehension' },
+          avg_ai_speech: { $avg: '$ai_speech_quality' },
+          avg_ai_content: { $avg: '$ai_content_quality' },
+          avg_no_unnecessary: { $avg: '$no_unnecessary_content' },
+          avg_patient_goal: { $avg: '$patient_reached_goal' },
+        },
+      },
+    ]);
+
+    const skippedCount = await ConversationEvaluation.countDocuments({ skipped: true });
+
+    // Per-evaluator stats
+    const evaluatorStats = await ConversationEvaluation.aggregate([
+      { $match: { skipped: { $ne: true } } },
+      {
+        $group: {
+          _id: '$evaluator_id',
+          name: { $first: '$evaluator_name' },
+          count: { $sum: 1 },
+          avg_score: { $avg: '$overall_score' },
+        },
+      },
+      { $sort: { count: -1 } },
+    ]);
+
+    return {
+      evaluations,
+      total,
+      page: pageNum,
+      totalPages: Math.ceil(total / limitNum),
+      stats: stats[0] || null,
+      skippedCount,
+      evaluatorStats,
+    };
+  });
+
+  // GET /admin/elevenlabs/conversations/:conversationId/evaluation
+  fastify.get<{
+    Params: { conversationId: string };
+  }>('/elevenlabs/conversations/:conversationId/evaluation', async (request, reply) => {
+    const { conversationId } = request.params;
+    const evaluation = await ConversationEvaluation.findOne({ conversation_id: conversationId }).lean();
+    if (!evaluation) {
+      return reply.status(404).send({ error: 'Evaluation not found' });
+    }
+    return evaluation;
+  });
+
+  // PUT /admin/elevenlabs/conversations/:conversationId/evaluation — upsert
+  fastify.put<{
+    Params: { conversationId: string };
+    Body: {
+      patient_audio_quality: number;
+      ai_comprehension: number;
+      ai_speech_quality: number;
+      ai_content_quality: number;
+      no_unnecessary_content: number;
+      patient_reached_goal: number;
+      notes?: string;
+    };
+  }>('/elevenlabs/conversations/:conversationId/evaluation', async (request) => {
+    const { conversationId } = request.params;
+    const { patient_audio_quality, ai_comprehension, ai_speech_quality, ai_content_quality, no_unnecessary_content, patient_reached_goal, notes } = request.body;
+    const jwtUser = request.user as { id: string; role: string };
+    const dbUser = await User.findById(jwtUser.id).select('name').lean();
+    const evaluatorName = dbUser?.name || 'Superadmin';
+
+    const criteria = [patient_audio_quality, ai_comprehension, ai_speech_quality, ai_content_quality, no_unnecessary_content, patient_reached_goal].filter((v) => v > 0);
+    const overall_score = criteria.length > 0 ? Math.round((criteria.reduce((a, b) => a + b, 0) / criteria.length) * 10) / 10 : 0;
+
+    const evaluation = await ConversationEvaluation.findOneAndUpdate(
+      { conversation_id: conversationId },
+      {
+        $set: {
+          evaluator_id: jwtUser.id,
+          evaluator_name: evaluatorName,
+          skipped: false,
+          patient_audio_quality: patient_audio_quality || null,
+          ai_comprehension: ai_comprehension || null,
+          ai_speech_quality: ai_speech_quality || null,
+          ai_content_quality: ai_content_quality || null,
+          no_unnecessary_content: no_unnecessary_content || null,
+          patient_reached_goal: patient_reached_goal || null,
+          overall_score,
+          notes: notes || '',
+        },
+      },
+      { upsert: true, new: true }
+    );
+
+    return evaluation;
+  });
+
+  // DELETE /admin/elevenlabs/conversations/:conversationId/evaluation
+  fastify.delete<{
+    Params: { conversationId: string };
+  }>('/elevenlabs/conversations/:conversationId/evaluation', async (request, reply) => {
+    const { conversationId } = request.params;
+    const result = await ConversationEvaluation.deleteOne({ conversation_id: conversationId });
+    if (result.deletedCount === 0) {
+      return reply.status(404).send({ error: 'Evaluation not found' });
+    }
+    return { deleted: true };
+  });
+
+  // POST /admin/elevenlabs/conversations/:conversationId/claim — claim for review (5 min TTL)
+  fastify.post<{
+    Params: { conversationId: string };
+  }>('/elevenlabs/conversations/:conversationId/claim', async (request) => {
+    const { conversationId } = request.params;
+    const jwtUser = request.user as { id: string };
+    const dbUser = await User.findById(jwtUser.id).select('name').lean();
+
+    await ConversationClaim.findOneAndUpdate(
+      { conversation_id: conversationId },
+      {
+        $set: {
+          user_id: jwtUser.id,
+          user_name: dbUser?.name || 'Superadmin',
+          expires_at: new Date(Date.now() + 5 * 60 * 1000), // 5 min TTL
+        },
+      },
+      { upsert: true }
+    );
+
+    return { claimed: true };
+  });
+
+  // POST /admin/elevenlabs/conversations/:conversationId/skip — mark as not evaluable
+  fastify.post<{
+    Params: { conversationId: string };
+    Body: { notes?: string };
+  }>('/elevenlabs/conversations/:conversationId/skip', async (request) => {
+    const { conversationId } = request.params;
+    const jwtUser = request.user as { id: string };
+    const dbUser = await User.findById(jwtUser.id).select('name').lean();
+    const evaluatorName = dbUser?.name || 'Superadmin';
+
+    const evaluation = await ConversationEvaluation.findOneAndUpdate(
+      { conversation_id: conversationId },
+      {
+        $set: {
+          evaluator_id: jwtUser.id,
+          evaluator_name: evaluatorName,
+          skipped: true,
+          notes: request.body?.notes || '',
+          overall_score: 0,
+        },
+      },
+      { upsert: true, new: true }
+    );
+
+    return evaluation;
+  });
+
+  // GET /admin/elevenlabs/inbound-calls — list SIP trunk inbound calls with phone metadata
+  fastify.get<{
+    Querystring: {
+      agent_id?: string;
+      page_size?: string;
+      cursor?: string;
+      call_successful?: string;
+      search?: string;
+    };
+  }>('/elevenlabs/inbound-calls', async (request) => {
+    const { agent_id, page_size, cursor, call_successful, search } = request.query;
+    const listResult = await elevenlabsService.listConversations({
+      agentId: agent_id || undefined,
+      pageSize: page_size ? parseInt(page_size, 10) : undefined,
+      cursor: cursor || undefined,
+      callSuccessful: call_successful as 'success' | 'failure' | 'unknown' | undefined,
+      search: search || undefined,
+      conversationInitiationSource: 'sip_trunk',
+    });
+
+    // Enrich each conversation with phone call metadata from detail endpoint
+    const enriched = await Promise.all(
+      listResult.conversations.map(async (c) => {
+        try {
+          const detail = await elevenlabsService.getConversation(c.conversationId);
+          const phoneCall = detail.metadata?.phoneCall;
+          return {
+            conversationId: c.conversationId,
+            agentId: c.agentId,
+            agentName: c.agentName,
+            status: c.status,
+            callSuccessful: c.callSuccessful,
+            callDurationSecs: c.callDurationSecs,
+            messageCount: c.messageCount,
+            direction: c.direction,
+            startTimeUnixSecs: c.startTimeUnixSecs,
+            rating: c.rating,
+            transcriptSummary: c.transcriptSummary,
+            phoneCallType: phoneCall ? (phoneCall as any).type : null,
+            callSid: phoneCall ? (phoneCall as any).callSid : null,
+            agentNumber: phoneCall ? (phoneCall as any).agentNumber : null,
+            externalNumber: phoneCall ? (phoneCall as any).externalNumber : null,
+            phoneNumberId: phoneCall ? (phoneCall as any).phoneNumberId : null,
+            terminationReason: detail.metadata?.terminationReason || null,
+            cost: detail.metadata?.cost ?? null,
+          };
+        } catch {
+          return {
+            conversationId: c.conversationId,
+            agentId: c.agentId,
+            agentName: c.agentName,
+            status: c.status,
+            callSuccessful: c.callSuccessful,
+            callDurationSecs: c.callDurationSecs,
+            messageCount: c.messageCount,
+            direction: c.direction,
+            startTimeUnixSecs: c.startTimeUnixSecs,
+            rating: c.rating,
+            transcriptSummary: c.transcriptSummary,
+            phoneCallType: null,
+            callSid: null,
+            agentNumber: null,
+            externalNumber: null,
+            phoneNumberId: null,
+            terminationReason: null,
+            cost: null,
+          };
+        }
+      })
+    );
+
+    return {
+      conversations: enriched,
+      hasMore: listResult.hasMore,
+      nextCursor: listResult.nextCursor,
+    };
+  });
+
+  // GET /admin/elevenlabs/batch-calls — list batch calls
+  fastify.get<{
+    Querystring: { limit?: string; last_doc?: string };
+  }>('/elevenlabs/batch-calls', async (request) => {
+    const { limit, last_doc } = request.query;
+    return elevenlabsService.listBatchCalls({
+      limit: limit ? parseInt(limit, 10) : undefined,
+      lastDoc: last_doc || undefined,
+    });
+  });
+
+  // GET /admin/elevenlabs/batch-calls/:batchId — get batch call detail
+  fastify.get<{
+    Params: { batchId: string };
+  }>('/elevenlabs/batch-calls/:batchId', async (request) => {
+    const { batchId } = request.params;
+    return elevenlabsService.getBatchCall(batchId);
+  });
+
+  // POST /admin/elevenlabs/batch-calls — trigger a new batch call
+  fastify.post('/elevenlabs/batch-calls', async (request, reply) => {
+    const { name, agent_id, phone_numbers } = request.body as {
+      name: string;
+      agent_id: string;
+      phone_numbers: string[];
+    };
+
+    if (!name || !agent_id || !phone_numbers?.length) {
+      return reply.status(400).send({ error: 'name, agent_id, and phone_numbers are required' });
+    }
+
+    const recipients = phone_numbers
+      .map((n) => n.trim())
+      .filter(Boolean)
+      .map((n) => ({ phoneNumber: n.startsWith('+') ? n : `+${n}` }));
+
+    if (recipients.length === 0) {
+      return reply.status(400).send({ error: 'At least one valid phone number is required' });
+    }
+
+    const result = await elevenlabsService.submitBatchCall({
+      callName: name,
+      agentId: agent_id,
+      recipients,
+    });
+
+    return reply.status(201).send(result);
+  });
+
+  // ─── ElevenLabs Webhook Management ──────────────────────────
+
+  // GET /admin/elevenlabs/webhooks — list workspace webhooks
+  fastify.get('/elevenlabs/webhooks', async () => {
+    return elevenlabsService.listWebhooks({ includeUsages: true });
+  });
+
+  // POST /admin/elevenlabs/webhooks — create workspace webhook
+  fastify.post('/elevenlabs/webhooks', async (request, reply) => {
+    const { name, webhookUrl } = request.body as { name: string; webhookUrl: string };
+    if (!name || !webhookUrl) {
+      return reply.status(400).send({ error: 'name and webhookUrl are required' });
+    }
+    return elevenlabsService.createWebhook({
+      settings: { authType: 'hmac', name, webhookUrl },
+    });
+  });
+
+  // PATCH /admin/elevenlabs/webhooks/:webhookId — update webhook
+  fastify.patch<{
+    Params: { webhookId: string };
+  }>('/elevenlabs/webhooks/:webhookId', async (request) => {
+    const { webhookId } = request.params;
+    const { isDisabled, name } = request.body as { isDisabled?: boolean; name?: string };
+    return elevenlabsService.updateWebhook(webhookId, {
+      isDisabled: isDisabled ?? false,
+      name: name ?? '',
+    });
+  });
+
+  // DELETE /admin/elevenlabs/webhooks/:webhookId — delete webhook
+  fastify.delete<{
+    Params: { webhookId: string };
+  }>('/elevenlabs/webhooks/:webhookId', async (request) => {
+    const { webhookId } = request.params;
+    return elevenlabsService.deleteWebhook(webhookId);
+  });
+
+  // PATCH /admin/elevenlabs/agents/:agentId/webhook — assign post-call webhook to agent
+  fastify.patch<{
+    Params: { agentId: string };
+  }>('/elevenlabs/agents/:agentId/webhook', async (request, reply) => {
+    const { agentId } = request.params;
+    const { postCallWebhookId, events } = request.body as {
+      postCallWebhookId: string;
+      events?: ('transcript' | 'audio' | 'call_initiation_failure')[];
+    };
+    if (!postCallWebhookId) {
+      return reply.status(400).send({ error: 'postCallWebhookId is required' });
+    }
+    return elevenlabsService.updateAgent(agentId, {
+      platformSettings: {
+        workspaceOverrides: {
+          webhooks: {
+            postCallWebhookId,
+            events: events || ['transcript'],
+          },
+        },
+      },
+    });
+  });
+
+  // DELETE /admin/elevenlabs/agents/:agentId/webhook — remove post-call webhook from agent
+  fastify.delete<{
+    Params: { agentId: string };
+  }>('/elevenlabs/agents/:agentId/webhook', async (request) => {
+    const { agentId } = request.params;
+    return elevenlabsService.updateAgent(agentId, {
+      platformSettings: {
+        workspaceOverrides: {
+          webhooks: {
+            postCallWebhookId: '',
+            events: [],
+          },
+        },
+      },
+    });
+  });
+
+  // ─── WhatsApp Bridge Provider ────────────────────────────────
+
+  // GET /admin/whatsapp-providers — List available bridge providers
+  fastify.get('/whatsapp-providers', async () => {
+    const unipileService = (await import('../../services/unipile.service')).default;
+    return { providers: unipileService.getAvailableProviders() };
+  });
+
+  // PUT /admin/tenants/:id/whatsapp-bridge — Set tenant's bridge provider
+  fastify.put<{ Params: { id: string } }>('/tenants/:id/whatsapp-bridge', async (request, reply) => {
+    const { id } = request.params;
+    const { provider } = request.body as { provider: string };
+
+    if (!['unipile', 'baileys'].includes(provider)) {
+      return reply.status(400).send({ error: 'Invalid provider. Must be "unipile" or "baileys"' });
+    }
+
+    const unipileService = (await import('../../services/unipile.service')).default;
+    if (!unipileService.isProviderReady(provider)) {
+      return reply.status(400).send({ error: `Provider "${provider}" is not configured on this server` });
+    }
+
+    const tenant = await Tenant.findById(id);
+    if (!tenant) {
+      return reply.status(404).send({ error: 'Tenant not found' });
+    }
+
+    // Refuse if tenant has active connection — must disconnect first
+    if (tenant.settings?.whatsapp_agent?.unipile_account_id) {
+      return reply.status(400).send({
+        error: 'Tenant has an active WhatsApp connection. Disconnect first before switching providers.',
+      });
+    }
+
+    await Tenant.findByIdAndUpdate(id, {
+      $set: { 'settings.whatsapp_agent.whatsapp_bridge_provider': provider }
+    });
+
+    return { success: true, provider };
+  });
+
+  // ─── Leads (cross-tenant) ──────────────────────────────────
+
+  // GET /admin/leads — all leads across tenants
+  fastify.get<{
+    Querystring: {
+      page?: string;
+      limit?: string;
+      lead_status?: string;
+      channel?: string;
+      category?: string;
+      tenant_id?: string;
+      date_from?: string;
+      date_to?: string;
+    };
+  }>('/leads', async (request) => {
+    const page = parseInt(request.query.page || '1', 10);
+    const limit = Math.min(parseInt(request.query.limit || '30', 10), 100);
+    const skip = (page - 1) * limit;
+
+    const filter: Record<string, unknown> = {};
+
+    if (request.query.tenant_id) filter.tenant_id = request.query.tenant_id;
+    if (request.query.lead_status) {
+      filter.lead_status = request.query.lead_status;
+    } else {
+      filter.lead_status = { $ne: 'expired' };
+    }
+    if (request.query.channel) filter.channel = request.query.channel;
+    if (request.query.category) filter.categories = request.query.category;
+    if (request.query.date_from || request.query.date_to) {
+      const dateFilter: Record<string, Date> = {};
+      if (request.query.date_from) dateFilter.$gte = new Date(request.query.date_from);
+      if (request.query.date_to) {
+        const to = new Date(request.query.date_to);
+        to.setHours(23, 59, 59, 999);
+        dateFilter.$lte = to;
+      }
+      filter.createdAt = dateFilter;
+    }
+
+    const [leads, total] = await Promise.all([
+      Lead.find(filter).sort({ createdAt: -1 }).skip(skip).limit(limit).lean(),
+      Lead.countDocuments(filter)
+    ]);
+
+    // Enrich with tenant names
+    const tenantIds = [...new Set(leads.map(l => String(l.tenant_id)))];
+    const tenants = await Tenant.find({ _id: { $in: tenantIds } }).select('name').lean();
+    const tenantMap = new Map(tenants.map(t => [String(t._id), t.name]));
+
+    const enriched = leads.map(l => ({
+      ...l,
+      tenant_name: tenantMap.get(String(l.tenant_id)) || '-',
+    }));
+
+    return {
+      leads: enriched,
+      total,
+      page,
+      totalPages: Math.ceil(total / limit)
+    };
+  });
+
+  // GET /admin/leads/stats — cross-tenant lead stats
+  fastify.get('/leads/stats', async () => {
+    const [total, byStatus, byChannel] = await Promise.all([
+      Lead.countDocuments({ lead_status: { $ne: 'expired' } }),
+      Lead.aggregate([
+        { $match: { lead_status: { $ne: 'expired' } } },
+        { $group: { _id: '$lead_status', count: { $sum: 1 } } }
+      ]),
+      Lead.aggregate([
+        { $match: { lead_status: { $ne: 'expired' } } },
+        { $group: { _id: '$channel', count: { $sum: 1 } } }
+      ])
+    ]);
+
+    const statusMap: Record<string, number> = {};
+    for (const s of byStatus) statusMap[s._id] = s.count;
+    const channelMap: Record<string, number> = {};
+    for (const c of byChannel) channelMap[c._id] = c.count;
+
+    return {
+      stats: {
+        total,
+        new: statusMap['new'] || 0,
+        contacted: statusMap['contacted'] || 0,
+        appointment_scheduled: statusMap['appointment_scheduled'] || 0,
+        completed: statusMap['completed'] || 0,
+        lost: statusMap['lost'] || 0,
+        phone: channelMap['phone'] || 0,
+        whatsapp: channelMap['whatsapp'] || 0,
+      }
+    };
+  });
+
+  // ─── WhatsApp (cross-tenant, read-only) ────────────────────
+
+  // GET /admin/whatsapp/stats — cross-tenant WhatsApp stats
+  fastify.get('/whatsapp/stats', async () => {
+    const [totalChats, closedChats, waitingSessions, activeSessions, totalMessages] = await Promise.all([
+      WhatsAppChat.countDocuments({ deleted_at: null }),
+      WhatsAppChat.countDocuments({ is_closed: true, deleted_at: null }),
+      WhatsAppSession.countDocuments({ status: 'waiting' }),
+      WhatsAppSession.countDocuments({ status: 'active' }),
+      WhatsAppMessage.countDocuments(),
+    ]);
+
+    const humanTakeoverCount = await WhatsAppSession.countDocuments({
+      status: 'active',
+      $or: [{ taken_over_by: { $ne: null } }, { taken_over_at: { $ne: null } }],
+    });
+
+    return {
+      stats: {
+        totalChats,
+        aiChats: activeSessions - humanTakeoverCount,
+        humanChats: humanTakeoverCount + waitingSessions,
+        closedChats,
+        waitingChats: waitingSessions,
+        totalMessages,
+      },
+    };
+  });
+
+  // GET /admin/whatsapp/agents — list WhatsApp agents assigned to tenants (for test chat)
+  fastify.get('/whatsapp/agents', async () => {
+    const tenants = await Tenant.find({
+      'settings.whatsapp_agent.agent_id': { $ne: null },
+    })
+      .select('name settings.whatsapp_agent.agent_id settings.whatsapp_agent.connected_phone')
+      .lean();
+
+    const agentIds = tenants
+      .map(t => t.settings?.whatsapp_agent?.agent_id)
+      .filter(Boolean);
+
+    const agents = await Agent.find({ _id: { $in: agentIds } })
+      .select('elevenlabs_agent_id is_active')
+      .lean();
+
+    const agentMap = new Map(agents.map(a => [String(a._id), a]));
+
+    const result = tenants
+      .map(t => {
+        const agentObjId = t.settings?.whatsapp_agent?.agent_id;
+        const agent = agentObjId ? agentMap.get(String(agentObjId)) : null;
+        if (!agent || !agent.elevenlabs_agent_id) return null;
+        return {
+          tenant_id: String(t._id),
+          tenant_name: t.name,
+          agent_id: String(agent._id),
+          elevenlabs_agent_id: agent.elevenlabs_agent_id,
+          is_active: agent.is_active,
+          connected_phone: t.settings?.whatsapp_agent?.connected_phone || null,
+        };
+      })
+      .filter(Boolean);
+
+    return { agents: result };
+  });
+
+  // GET /admin/whatsapp/contact-profiles — cross-tenant contact profiles (for test chat)
+  fastify.get<{
+    Querystring: { search?: string; limit?: string };
+  }>('/whatsapp/contact-profiles', async (request) => {
+    const limit = Math.min(parseInt(request.query.limit || '50', 10), 100);
+    const search = request.query.search?.trim();
+
+    const filter: Record<string, unknown> = {};
+    if (search) {
+      filter.$or = [
+        { display_name: { $regex: search, $options: 'i' } },
+        { phone: { $regex: search, $options: 'i' } },
+      ];
+    }
+
+    const profiles = await WhatsAppContactProfile.find(filter)
+      .select('display_name phone ai_summary preferred_language tenant_id tags total_sessions')
+      .sort({ last_seen_at: -1 })
+      .limit(limit)
+      .lean();
+
+    // Truncate ai_summary to 100 chars for listing
+    const result = profiles.map(p => ({
+      ...p,
+      ai_summary: p.ai_summary ? p.ai_summary.substring(0, 100) + (p.ai_summary.length > 100 ? '...' : '') : '',
+    }));
+
+    return { profiles: result };
+  });
+
+  // GET /admin/whatsapp/chats — list all chats across tenants
+  fastify.get<{
+    Querystring: { page?: string; limit?: string; tenant_id?: string; search?: string };
+  }>('/whatsapp/chats', async (request) => {
+    const page = parseInt(request.query.page || '1', 10);
+    const limit = Math.min(parseInt(request.query.limit || '20', 10), 100);
+    const skip = (page - 1) * limit;
+
+    const filter: Record<string, unknown> = { deleted_at: null };
+    if (request.query.tenant_id) {
+      filter.tenant_id = new mongoose.Types.ObjectId(request.query.tenant_id);
+    }
+
+    const pipeline: any[] = [
+      { $match: filter },
+      { $sort: { last_message_at: -1 as const } },
+      {
+        $lookup: {
+          from: 'tenants',
+          localField: 'tenant_id',
+          foreignField: '_id',
+          as: '_tenant',
+        },
+      },
+      { $unwind: { path: '$_tenant', preserveNullAndEmptyArrays: true } },
+    ];
+
+    // Search by contact name/phone or tenant name
+    if (request.query.search) {
+      const regex = { $regex: request.query.search, $options: 'i' };
+      pipeline.push({
+        $match: {
+          $or: [
+            { contact_name: regex },
+            { contact_phone: regex },
+            { '_tenant.name': regex },
+          ],
+        },
+      });
+    }
+
+    pipeline.push(
+      {
+        $project: {
+          tenant_id: 1,
+          tenant_name: { $ifNull: ['$_tenant.name', 'Bilinmiyor'] },
+          unipile_chat_id: 1,
+          contact_name: 1,
+          contact_phone: 1,
+          is_closed: 1,
+          active_session_id: 1,
+          last_message_at: 1,
+          last_message_preview: 1,
+          message_count: 1,
+          createdAt: 1,
+        },
+      },
+      {
+        $facet: {
+          data: [{ $skip: skip }, { $limit: limit }],
+          count: [{ $count: 'total' }],
+        },
+      },
+    );
+
+    const [result] = await WhatsAppChat.aggregate(pipeline);
+    const chats = result?.data || [];
+    const total = result?.count?.[0]?.total || 0;
+
+    return { chats, total, page, totalPages: Math.ceil(total / limit) };
+  });
+
+  // GET /admin/whatsapp/chats/:chatId — single chat detail
+  fastify.get<{ Params: { chatId: string } }>('/whatsapp/chats/:chatId', async (request, reply) => {
+    const { chatId } = request.params;
+    const chat = await WhatsAppChat.findById(chatId).lean();
+    if (!chat) return reply.status(404).send({ error: 'Chat not found' });
+
+    const tenant = await Tenant.findById(chat.tenant_id).select('name settings.whatsapp_agent.grace_period_seconds').lean();
+
+    return {
+      chat: {
+        ...chat,
+        tenant_name: tenant?.name || 'Bilinmiyor',
+        grace_period_seconds: tenant?.settings?.whatsapp_agent?.grace_period_seconds ?? 180,
+      },
+    };
+  });
+
+  // GET /admin/whatsapp/chats/:chatId/messages — messages for a chat
+  fastify.get<{
+    Params: { chatId: string };
+    Querystring: { page?: string; limit?: string };
+  }>('/whatsapp/chats/:chatId/messages', async (request, reply) => {
+    const { chatId } = request.params;
+    const page = parseInt(request.query.page || '1', 10);
+    const limit = Math.min(parseInt(request.query.limit || '50', 10), 200);
+    const skip = (page - 1) * limit;
+
+    const chat = await WhatsAppChat.findById(chatId);
+    if (!chat) return reply.status(404).send({ error: 'Chat not found' });
+
+    const [messages, total] = await Promise.all([
+      WhatsAppMessage.find({ chat_id: chatId })
+        .sort({ createdAt: 1 })
+        .skip(skip)
+        .limit(limit)
+        .lean(),
+      WhatsAppMessage.countDocuments({ chat_id: chatId }),
+    ]);
+
+    return { messages, total, page, totalPages: Math.ceil(total / limit) };
+  });
+
+  // GET /admin/whatsapp/chats/:chatId/sessions — session history for a chat
+  fastify.get<{
+    Params: { chatId: string };
+    Querystring: { page?: string; limit?: string };
+  }>('/whatsapp/chats/:chatId/sessions', async (request, reply) => {
+    const { chatId } = request.params;
+    const page = parseInt(request.query.page || '1', 10);
+    const limit = Math.min(parseInt(request.query.limit || '20', 10), 50);
+    const skip = (page - 1) * limit;
+
+    const chat = await WhatsAppChat.findById(chatId);
+    if (!chat) return reply.status(404).send({ error: 'Chat not found' });
+
+    const [sessions, total] = await Promise.all([
+      WhatsAppSession.find({ chat_id: chatId })
+        .populate('taken_over_by', 'name email')
+        .sort({ started_at: -1 })
+        .skip(skip)
+        .limit(limit)
+        .lean(),
+      WhatsAppSession.countDocuments({ chat_id: chatId }),
+    ]);
+
+    return { sessions, total, page, totalPages: Math.ceil(total / limit) };
+  });
+
+  // DELETE /admin/whatsapp/chats/:chatId — HARD delete chat + messages + sessions
+  fastify.delete<{ Params: { chatId: string } }>('/whatsapp/chats/:chatId', async (request, reply) => {
+    const { chatId } = request.params;
+    const chat = await WhatsAppChat.findById(chatId);
+    if (!chat) return reply.status(404).send({ error: 'Chat not found' });
+
+    // 1. Close any active WS connection and cancel timers
+    if (chat.unipile_chat_id) {
+      whatsappAgentService.closeConnection(chat.unipile_chat_id);
+    }
+    if (chat.active_session_id) {
+      whatsappAgentService.cancelSession(chat.active_session_id.toString());
+    }
+
+    // 2. Hard-delete all related documents
+    const [msgResult, sessResult] = await Promise.all([
+      WhatsAppMessage.deleteMany({ chat_id: chatId }),
+      WhatsAppSession.deleteMany({ chat_id: chatId }),
+    ]);
+
+    // 3. Delete linked contact profile
+    let profileDeleted = 0;
+    if (chat.contact_profile_id) {
+      const res = await WhatsAppContactProfile.deleteOne({ _id: chat.contact_profile_id });
+      profileDeleted = res.deletedCount;
+    }
+
+    // 4. Hard-delete the chat itself
+    await WhatsAppChat.deleteOne({ _id: chatId });
+
+    return {
+      deleted: {
+        chat: 1,
+        messages: msgResult.deletedCount,
+        sessions: sessResult.deletedCount,
+        contactProfile: profileDeleted,
+      },
+    };
+  });
+
+  // PUT /admin/whatsapp/grace-period — set grace period for a tenant (no minimum, for debugging)
+  fastify.put<{
+    Body: { tenant_id: string; grace_period_seconds: number };
+  }>('/whatsapp/grace-period', async (request, reply) => {
+    const body = request.body as { tenant_id?: string; grace_period_seconds?: number } | null;
+    const tenant_id = body?.tenant_id ? String(body.tenant_id) : null;
+    const grace_period_seconds = body?.grace_period_seconds;
+
+    if (!tenant_id || grace_period_seconds === undefined || grace_period_seconds === null) {
+      return reply.status(400).send({ error: 'tenant_id and grace_period_seconds required' });
+    }
+
+    const clamped = Math.max(1, Math.min(1800, Math.floor(grace_period_seconds)));
+
+    const tenant = await Tenant.findByIdAndUpdate(
+      new mongoose.Types.ObjectId(tenant_id),
+      { $set: { 'settings.whatsapp_agent.grace_period_seconds': clamped } },
+      { new: true },
+    );
+
+    if (!tenant) return reply.status(404).send({ error: 'Tenant not found' });
+
+    return {
+      tenant_id: String(tenant._id),
+      grace_period_seconds: tenant.settings?.whatsapp_agent?.grace_period_seconds ?? clamped,
+    };
+  });
+
+  // POST /admin/whatsapp/chats/:chatId/force-resolve — force-end active session (debug)
+  fastify.post<{ Params: { chatId: string } }>('/whatsapp/chats/:chatId/force-resolve', async (request, reply) => {
+    const { chatId } = request.params;
+    const chat = await WhatsAppChat.findById(chatId);
+    if (!chat) return reply.status(404).send({ error: 'Chat not found' });
+
+    if (!chat.active_session_id) {
+      return reply.status(400).send({ error: 'No active session' });
+    }
+
+    const session = await WhatsAppSession.findById(chat.active_session_id);
+    if (!session || session.status === 'resolved') {
+      chat.active_session_id = null;
+      await chat.save();
+      return reply.status(400).send({ error: 'Session already resolved' });
+    }
+
+    // Cancel timers (grace period + message buffer)
+    whatsappAgentService.cancelSession(session._id.toString());
+
+    // Close ElevenLabs WebSocket connection
+    whatsappAgentService.closeConnection(chat.unipile_chat_id);
+
+    // Resolve the session
+    session.status = 'resolved';
+    session.resolved_by = 'manual';
+    session.resolved_at = new Date();
+    await session.save();
+
+    // Clear active session from chat
+    chat.active_session_id = null;
+    await chat.save();
+
+    // Generate AI profile summary + labels from the session transcript
+    whatsappAgentService.updateContactProfileSummary(session._id.toString()).catch(err => {
+      fastify.log.error({ error: (err as Error).message }, 'Profile summary update failed after force-resolve');
+    });
+    whatsappAgentService.generateSessionLabels(session._id.toString()).catch(err => {
+      fastify.log.error({ error: (err as Error).message }, 'Session labelling failed after force-resolve');
+    });
+
+    return {
+      resolved: {
+        session_id: String(session._id),
+        previous_status: session.status === 'resolved' ? 'resolved' : (session.taken_over_by ? 'active (human)' : session.status),
+      },
+    };
+  });
+
+  // ─── Baileys Logs ─────────────────────────────────────────
+
+  /**
+   * Build accountId→tenant lookup map.
+   * Maps Baileys account UUIDs to { tenant_id, tenant_name }.
+   */
+  async function buildAccountTenantMap() {
+    const tenants = await Tenant.find(
+      { 'settings.whatsapp_agent.unipile_account_id': { $ne: null } },
+      { name: 1, 'settings.whatsapp_agent.unipile_account_id': 1 },
+    ).lean();
+    const map = new Map<string, { tenant_id: string; tenant_name: string }>();
+    for (const t of tenants) {
+      const aid = t.settings?.whatsapp_agent?.unipile_account_id;
+      if (aid) map.set(aid, { tenant_id: String(t._id), tenant_name: t.name });
+    }
+    return map;
+  }
+
+  // GET /admin/baileys/raw-messages
+  fastify.get<{
+    Querystring: { page?: string; limit?: string; tenant_id?: string; from_me?: string; date_from?: string; date_to?: string };
+  }>('/baileys/raw-messages', async (request) => {
+    const page = parseInt(request.query.page || '1', 10);
+    const limit = Math.min(parseInt(request.query.limit || '30', 10), 100);
+    const skip = (page - 1) * limit;
+
+    const db = mongoose.connection.db;
+    if (!db) return { logs: [], total: 0, page, totalPages: 0 };
+
+    const accountMap = await buildAccountTenantMap();
+
+    const filter: Record<string, unknown> = {};
+
+    // Filter by tenant → find matching accountId
+    if (request.query.tenant_id) {
+      const accountIds: string[] = [];
+      for (const [aid, info] of accountMap) {
+        if (info.tenant_id === request.query.tenant_id) accountIds.push(aid);
+      }
+      filter.accountId = { $in: accountIds };
+    }
+
+    if (request.query.from_me === 'true') filter['key.fromMe'] = true;
+    else if (request.query.from_me === 'false') filter['key.fromMe'] = false;
+
+    if (request.query.date_from || request.query.date_to) {
+      const dateFilter: Record<string, Date> = {};
+      if (request.query.date_from) dateFilter.$gte = new Date(request.query.date_from);
+      if (request.query.date_to) dateFilter.$lte = new Date(request.query.date_to + 'T23:59:59.999Z');
+      filter.createdAt = dateFilter;
+    }
+
+    const col = db.collection('baileys_raw_messages');
+    const [docs, total] = await Promise.all([
+      col.find(filter).sort({ createdAt: -1 }).skip(skip).limit(limit).toArray(),
+      col.countDocuments(filter),
+    ]);
+
+    const logs = docs.map(doc => ({
+      ...doc,
+      tenant_name: accountMap.get(doc.accountId)?.tenant_name || '-',
+      tenant_id: accountMap.get(doc.accountId)?.tenant_id || null,
+    }));
+
+    return { logs, total, page, totalPages: Math.ceil(total / limit) };
+  });
+
+  // GET /admin/baileys/message-log
+  fastify.get<{
+    Querystring: { page?: string; limit?: string; tenant_id?: string; action?: string; reason?: string; date_from?: string; date_to?: string };
+  }>('/baileys/message-log', async (request) => {
+    const page = parseInt(request.query.page || '1', 10);
+    const limit = Math.min(parseInt(request.query.limit || '30', 10), 100);
+    const skip = (page - 1) * limit;
+
+    const db = mongoose.connection.db;
+    if (!db) return { logs: [], total: 0, page, totalPages: 0 };
+
+    const accountMap = await buildAccountTenantMap();
+
+    const filter: Record<string, unknown> = {};
+
+    if (request.query.tenant_id) {
+      const accountIds: string[] = [];
+      for (const [aid, info] of accountMap) {
+        if (info.tenant_id === request.query.tenant_id) accountIds.push(aid);
+      }
+      filter.accountId = { $in: accountIds };
+    }
+
+    if (request.query.action) filter.action = request.query.action;
+    if (request.query.reason) filter.reason = { $regex: request.query.reason, $options: 'i' };
+
+    if (request.query.date_from || request.query.date_to) {
+      const dateFilter: Record<string, Date> = {};
+      if (request.query.date_from) dateFilter.$gte = new Date(request.query.date_from);
+      if (request.query.date_to) dateFilter.$lte = new Date(request.query.date_to + 'T23:59:59.999Z');
+      filter.createdAt = dateFilter;
+    }
+
+    const col = db.collection('baileys_message_log');
+    const [docs, total] = await Promise.all([
+      col.find(filter).sort({ createdAt: -1 }).skip(skip).limit(limit).toArray(),
+      col.countDocuments(filter),
+    ]);
+
+    const logs = docs.map(doc => ({
+      ...doc,
+      tenant_name: accountMap.get(doc.accountId)?.tenant_name || '-',
+      tenant_id: accountMap.get(doc.accountId)?.tenant_id || null,
+    }));
+
+    return { logs, total, page, totalPages: Math.ceil(total / limit) };
+  });
+
+  // GET /admin/baileys/message-log/stats — quick summary of action counts
+  fastify.get('/baileys/message-log/stats', async () => {
+    const db = mongoose.connection.db;
+    if (!db) return { stats: {} };
+
+    const col = db.collection('baileys_message_log');
+    const pipeline = [
+      { $group: { _id: '$action', count: { $sum: 1 } } },
+      { $sort: { count: -1 as const } },
+    ];
+    const results = await col.aggregate(pipeline).toArray();
+    const stats: Record<string, number> = {};
+    for (const r of results) stats[r._id] = r.count;
+    return { stats };
+  });
+
+  // ─── ElevenLabs Credit Analytics ────────────────────────────
+  // GET /admin/elevenlabs/credits — cross-tenant credit usage analytics
+  fastify.get<{
+    Querystring: { from?: string; to?: string; tenant_id?: string };
+  }>('/elevenlabs/credits', async (request, reply) => {
+    const now = new Date();
+    const monthStart = new Date(now.getFullYear(), now.getMonth(), 1);
+    const from = request.query.from ? new Date(request.query.from) : monthStart;
+    const to = request.query.to ? new Date(request.query.to) : now;
+
+    if (isNaN(from.getTime()) || isNaN(to.getTime())) {
+      return reply.status(400).send({ error: 'Invalid date format for from/to' });
+    }
+
+    const tenantFilter = request.query.tenant_id
+      ? { tenant_id: new mongoose.Types.ObjectId(request.query.tenant_id) }
+      : {};
+
+    const [waPerTenant, callPerTenant, waDailyRows, callDailyRows, tenantList, waDailyPerTenantRows, callDailyPerTenantRows] = await Promise.all([
+      // Q1: WA credits per tenant
+      WhatsAppSession.aggregate([
+        { $match: { started_at: { $gte: from, $lte: to }, elevenlabs_cost: { $ne: null, $gt: 0 }, ...tenantFilter } },
+        { $group: { _id: '$tenant_id', wa_credits: { $sum: '$elevenlabs_cost' }, wa_session_count: { $sum: 1 } } },
+      ]),
+
+      // Q2: Call credits per tenant
+      Call.aggregate([
+        { $match: { createdAt: { $gte: from, $lte: to }, cost: { $ne: null, $gt: 0 }, ...tenantFilter } },
+        { $group: { _id: '$tenant_id', call_credits: { $sum: '$cost' }, call_count: { $sum: 1 } } },
+      ]),
+
+      // Q3: WA daily trend
+      WhatsAppSession.aggregate([
+        { $match: { started_at: { $gte: from, $lte: to }, elevenlabs_cost: { $ne: null, $gt: 0 }, ...tenantFilter } },
+        { $group: { _id: { $dateToString: { format: '%Y-%m-%d', date: '$started_at' } }, wa: { $sum: '$elevenlabs_cost' } } },
+        { $sort: { _id: 1 } },
+      ]),
+
+      // Q4: Call daily trend
+      Call.aggregate([
+        { $match: { createdAt: { $gte: from, $lte: to }, cost: { $ne: null, $gt: 0 }, ...tenantFilter } },
+        { $group: { _id: { $dateToString: { format: '%Y-%m-%d', date: '$createdAt' } }, calls: { $sum: '$cost' } } },
+        { $sort: { _id: 1 } },
+      ]),
+
+      // Q5: Tenant list for dropdown
+      Tenant.find({}).select('name').lean(),
+
+      // Q6: WA daily trend per tenant
+      WhatsAppSession.aggregate([
+        { $match: { started_at: { $gte: from, $lte: to }, elevenlabs_cost: { $ne: null, $gt: 0 }, ...tenantFilter } },
+        { $group: { _id: { date: { $dateToString: { format: '%Y-%m-%d', date: '$started_at' } }, tenant_id: '$tenant_id' }, credits: { $sum: '$elevenlabs_cost' } } },
+        { $sort: { '_id.date': 1 } },
+      ]),
+
+      // Q7: Call daily trend per tenant
+      Call.aggregate([
+        { $match: { createdAt: { $gte: from, $lte: to }, cost: { $ne: null, $gt: 0 }, ...tenantFilter } },
+        { $group: { _id: { date: { $dateToString: { format: '%Y-%m-%d', date: '$createdAt' } }, tenant_id: '$tenant_id' }, credits: { $sum: '$cost' } } },
+        { $sort: { '_id.date': 1 } },
+      ]),
+    ]);
+
+    // Build tenant name map
+    const tenantMap = new Map<string, string>();
+    for (const t of tenantList) tenantMap.set(String(t._id), t.name);
+
+    // Merge per-tenant results
+    const perTenantMap = new Map<string, { tenant_id: string; tenant_name: string; wa_credits: number; call_credits: number; total_credits: number; wa_session_count: number; call_count: number }>();
+    for (const row of waPerTenant) {
+      const tid = String(row._id);
+      perTenantMap.set(tid, {
+        tenant_id: tid, tenant_name: tenantMap.get(tid) || 'Bilinmiyor',
+        wa_credits: row.wa_credits, call_credits: 0, total_credits: row.wa_credits,
+        wa_session_count: row.wa_session_count, call_count: 0,
+      });
+    }
+    for (const row of callPerTenant) {
+      const tid = String(row._id);
+      const existing = perTenantMap.get(tid);
+      if (existing) {
+        existing.call_credits = row.call_credits;
+        existing.call_count = row.call_count;
+        existing.total_credits = existing.wa_credits + row.call_credits;
+      } else {
+        perTenantMap.set(tid, {
+          tenant_id: tid, tenant_name: tenantMap.get(tid) || 'Bilinmiyor',
+          wa_credits: 0, call_credits: row.call_credits, total_credits: row.call_credits,
+          wa_session_count: 0, call_count: row.call_count,
+        });
+      }
+    }
+    const per_tenant = [...perTenantMap.values()].sort((a, b) => b.total_credits - a.total_credits);
+
+    // Summary from per_tenant
+    const summary = per_tenant.reduce(
+      (acc, t) => ({
+        total_credits: acc.total_credits + t.total_credits,
+        wa_credits: acc.wa_credits + t.wa_credits,
+        call_credits: acc.call_credits + t.call_credits,
+        wa_session_count: acc.wa_session_count + t.wa_session_count,
+        call_count: acc.call_count + t.call_count,
+      }),
+      { total_credits: 0, wa_credits: 0, call_credits: 0, wa_session_count: 0, call_count: 0 },
+    );
+
+    // Fill daily trend with zeros for missing days
+    const waMap = new Map(waDailyRows.map((r: { _id: string; wa: number }) => [r._id, r.wa]));
+    const callMap = new Map(callDailyRows.map((r: { _id: string; calls: number }) => [r._id, r.calls]));
+    const daily_trend: { date: string; wa: number; calls: number }[] = [];
+    const cursor = new Date(from);
+    cursor.setHours(0, 0, 0, 0);
+    const endDate = new Date(to);
+    endDate.setHours(0, 0, 0, 0);
+    while (cursor <= endDate) {
+      const key = cursor.toISOString().slice(0, 10);
+      daily_trend.push({ date: key, wa: waMap.get(key) || 0, calls: callMap.get(key) || 0 });
+      cursor.setDate(cursor.getDate() + 1);
+    }
+
+    // Build per-tenant daily trends (one key per tenant per day)
+    // Result: array of { date, [tenantName]: credits, ... } for recharts multi-line
+    const activeTenantIds = new Set<string>();
+    const waPTMap = new Map<string, Map<string, number>>();   // date -> tenantId -> credits
+    const callPTMap = new Map<string, Map<string, number>>();
+
+    for (const row of waDailyPerTenantRows) {
+      const { date, tenant_id } = row._id as { date: string; tenant_id: mongoose.Types.ObjectId };
+      const tid = String(tenant_id);
+      activeTenantIds.add(tid);
+      if (!waPTMap.has(date)) waPTMap.set(date, new Map());
+      waPTMap.get(date)!.set(tid, row.credits);
+    }
+    for (const row of callDailyPerTenantRows) {
+      const { date, tenant_id } = row._id as { date: string; tenant_id: mongoose.Types.ObjectId };
+      const tid = String(tenant_id);
+      activeTenantIds.add(tid);
+      if (!callPTMap.has(date)) callPTMap.set(date, new Map());
+      callPTMap.get(date)!.set(tid, row.credits);
+    }
+
+    // Active tenants with names (sorted by total credits)
+    const activeTenants = per_tenant
+      .filter(t => activeTenantIds.has(t.tenant_id))
+      .map(t => ({ id: t.tenant_id, name: t.tenant_name }));
+
+    // Fill daily per-tenant data
+    const wa_daily_per_tenant: Record<string, unknown>[] = [];
+    const call_daily_per_tenant: Record<string, unknown>[] = [];
+    const c2 = new Date(from);
+    c2.setHours(0, 0, 0, 0);
+    while (c2 <= endDate) {
+      const key = c2.toISOString().slice(0, 10);
+      const waDay: Record<string, unknown> = { date: key };
+      const callDay: Record<string, unknown> = { date: key };
+      for (const t of activeTenants) {
+        waDay[t.name] = waPTMap.get(key)?.get(t.id) || 0;
+        callDay[t.name] = callPTMap.get(key)?.get(t.id) || 0;
+      }
+      wa_daily_per_tenant.push(waDay);
+      call_daily_per_tenant.push(callDay);
+      c2.setDate(c2.getDate() + 1);
+    }
+
+    return {
+      summary,
+      daily_trend,
+      per_tenant,
+      wa_daily_per_tenant,
+      call_daily_per_tenant,
+      active_tenants: activeTenants,
+      tenants: tenantList.map(t => ({ _id: String(t._id), name: t.name })),
+    };
+  });
+}