elevenlabs-webhook-nodejs 1.0.0

package/dist/modules/admin/admin.routes.js

@@ -0,0 +1,1966 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = superAdminRoutes;
+const mongoose_1 = __importDefault(require("mongoose"));
+const tenant_model_1 = __importStar(require("../tenants/tenant.model"));
+const auth_model_1 = __importDefault(require("../auth/auth.model"));
+const agent_model_1 = __importDefault(require("../agents/agent.model"));
+const call_model_1 = __importDefault(require("../calls/call.model"));
+const campaign_model_1 = __importDefault(require("../campaigns/campaign.model"));
+const billing_model_1 = __importDefault(require("../billing/billing.model"));
+const rbac_1 = require("../../plugins/rbac");
+const auth_service_1 = require("../auth/auth.service");
+const plan_model_1 = __importDefault(require("../plans/plan.model"));
+const payment_model_1 = __importDefault(require("../billing/payment.model"));
+const elevenlabs_service_1 = __importDefault(require("../../services/elevenlabs.service"));
+const billing_service_1 = require("../billing/billing.service");
+const logger_1 = __importDefault(require("../../utils/logger"));
+const elevenlabs_test_chat_routes_1 = __importDefault(require("./elevenlabs-test-chat.routes"));
+const whatsapp_test_chat_routes_1 = __importDefault(require("./whatsapp-test-chat.routes"));
+const migration_routes_1 = __importDefault(require("../../migrations/migration.routes"));
+const whatsapp_session_model_1 = __importDefault(require("../whatsapp/whatsapp-session.model"));
+const whatsapp_message_model_1 = __importDefault(require("../whatsapp/whatsapp-message.model"));
+const whatsapp_chat_model_1 = __importDefault(require("../whatsapp/whatsapp-chat.model"));
+const whatsapp_contact_profile_model_1 = __importDefault(require("../whatsapp/whatsapp-contact-profile.model"));
+const whatsapp_agent_service_1 = __importDefault(require("../../services/whatsapp-agent.service"));
+const lead_model_1 = __importDefault(require("../leads/lead.model"));
+const ConversationEvaluation_1 = __importDefault(require("../../models/ConversationEvaluation"));
+const ConversationClaim_1 = __importDefault(require("../../models/ConversationClaim"));
+const stream_1 = require("stream");
+async function superAdminRoutes(fastify) {
+    fastify.addHook('preHandler', fastify.authenticate);
+    fastify.addHook('preHandler', (0, rbac_1.requireRole)('superadmin'));
+    // Register sub-routes
+    await fastify.register(elevenlabs_test_chat_routes_1.default, { prefix: '/elevenlabs/test-chat' });
+    await fastify.register(whatsapp_test_chat_routes_1.default, { prefix: '/whatsapp/test-chat' });
+    await fastify.register(migration_routes_1.default, { prefix: '/migrations' });
+    // ─── Tenants ────────────────────────────────────────────────
+    // GET /admin/tenants — list all tenants with user count
+    fastify.get('/tenants', async (request) => {
+        const page = parseInt(request.query.page || '1', 10);
+        const limit = 20;
+        const skip = (page - 1) * limit;
+        const filter = { $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_model_1.default.find(filter).sort({ createdAt: -1 }).skip(skip).limit(limit).lean(),
+            tenant_model_1.default.countDocuments(filter)
+        ]);
+        // Attach user count per tenant
+        const tenantIds = tenants.map(t => t._id);
+        const userCounts = await auth_model_1.default.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;
+        if (!name) {
+            return reply.status(400).send({ error: 'name is required' });
+        }
+        const tenant = await tenant_model_1.default.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;
+        const tenant = await tenant_model_1.default.findById(id).lean();
+        if (!tenant) {
+            return reply.status(404).send({ error: 'Tenant not found' });
+        }
+        const [users, agents, callCount, campaignCount] = await Promise.all([
+            auth_model_1.default.find({ tenant_id: id }).select('name email role createdAt').lean(),
+            agent_model_1.default.find({ tenant_id: id }).lean(),
+            call_model_1.default.countDocuments({ tenant_id: id }),
+            campaign_model_1.default.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;
+        const { name, plan, enabled_features, settings } = request.body;
+        const tenant = await tenant_model_1.default.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 => tenant_model_1.AVAILABLE_FEATURES.includes(f));
+        }
+        if (settings) {
+            const { whatsapp_agent, ...rest } = settings;
+            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;
+        const { enabled_features } = request.body;
+        const tenant = await tenant_model_1.default.findById(id);
+        if (!tenant) {
+            return reply.status(404).send({ error: 'Tenant not found' });
+        }
+        tenant.enabled_features = enabled_features.filter(f => tenant_model_1.AVAILABLE_FEATURES.includes(f));
+        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;
+        const tenant = await tenant_model_1.default.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_1.default.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;
+        const tenant = await tenant_model_1.default.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_1.default.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;
+        const tenant = await tenant_model_1.default.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_1.default.Types.ObjectId(id);
+        // Mangle unique fields to avoid conflicts, mark as deleted
+        await Promise.all([
+            // Mangle user emails so they can re-register
+            auth_model_1.default.updateMany({ tenant_id: tenantOid }, [{ $set: { email: { $concat: ['$email', suffix] }, is_active: false } }]),
+            // Deactivate agents
+            agent_model_1.default.updateMany({ tenant_id: tenantOid }, { $set: { is_active: false } }),
+            // Mangle tenant name
+            tenant_model_1.default.updateOne({ _id: tenantOid }, { $set: { name: `${tenant.name}${suffix}`, is_active: false, deleted_at: new Date() } }),
+        ]);
+        logger_1.default.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;
+        const { email, password, name, role } = request.body;
+        if (!email || !password || !name) {
+            return reply.status(400).send({ error: 'email, password, and name are required' });
+        }
+        const tenant = await tenant_model_1.default.findById(id);
+        if (!tenant) {
+            return reply.status(404).send({ error: 'Tenant not found' });
+        }
+        const existing = await auth_model_1.default.findOne({ email: email.toLowerCase() });
+        if (existing) {
+            return reply.status(409).send({ error: 'Bu e-posta zaten kullaniliyor' });
+        }
+        const password_hash = await (0, auth_service_1.hashPassword)(password);
+        const user = await auth_model_1.default.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 elevenlabs_service_1.default.listAgents({ pageSize: 100 });
+        // Get all already-assigned ElevenLabs agent IDs
+        const assignedIds = await agent_model_1.default.distinct('elevenlabs_agent_id');
+        const assignedSet = new Set(assignedIds);
+        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;
+        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_model_1.default.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_model_1.default.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_model_1.default.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 || 'openai',
+                whatsapp_notify: true,
+                notification_template: 'call_summary',
+                summary_prompt: post_call_processing?.summary_prompt || '',
+                system_message: '',
+                whatsapp_message_template: post_call_processing?.whatsapp_message_template || ''
+            },
+            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;
+        const { phone_number, direction, is_active, post_call_processing } = request.body;
+        const agent = await agent_model_1.default.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;
+        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_model_1.default.countDocuments(),
+            auth_model_1.default.countDocuments(),
+            agent_model_1.default.countDocuments(),
+            call_model_1.default.countDocuments(),
+            call_model_1.default.countDocuments({ createdAt: { $gte: todayStart } }),
+            campaign_model_1.default.countDocuments({ status: { $in: ['running', 'scheduled'] } }),
+            billing_model_1.default.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_model_1.default.aggregate([
+                { $match: { createdAt: { $gte: monthStart } } },
+                { $group: { _id: '$status', count: { $sum: 1 } } }
+            ]),
+            // Daily trend last 7 days
+            call_model_1.default.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 = { completed: 0, failed: 0, no_answer: 0, voicemail: 0, transferred: 0 };
+        callStatusRows.forEach((r) => { callStatusBreakdown[r._id] = r.count; });
+        // Fill 7-day trend with zeros for missing days
+        const dailyTrend = [];
+        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) => 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_1.default.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_model_1.default.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_model_1.default.find().lean(),
+            payment_model_1.default.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) => [String(t._id), t.extra_minutes]));
+        const enriched = usagePerTenant.map((u) => {
+            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_model_1.default.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;
+        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_model_1.default.findOne({ slug });
+        if (existing) {
+            return reply.status(409).send({ error: 'Bu slug zaten kullaniliyor' });
+        }
+        const plan = await plan_model_1.default.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;
+        const updates = request.body;
+        const plan = await plan_model_1.default.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[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_model_1.default.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_model_1.default.insertMany(defaults);
+        return reply.status(201).send({ plans });
+    });
+    // ─── Payments ───────────────────────────────────────────────
+    // GET /admin/payments — list all payments (filterable by tenant_id)
+    fastify.get('/payments', async (request) => {
+        const page = parseInt(request.query.page || '1', 10);
+        const limit = 20;
+        const skip = (page - 1) * limit;
+        const filter = {};
+        if (request.query.tenant_id) {
+            filter.tenant_id = request.query.tenant_id;
+        }
+        const [payments, total] = await Promise.all([
+            payment_model_1.default.find(filter).sort({ period_start: -1 }).skip(skip).limit(limit).lean(),
+            payment_model_1.default.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;
+        const payments = await payment_model_1.default.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('/tenants/:id/billable-items', async (request, reply) => {
+        const { id } = request.params;
+        const tenant = await tenant_model_1.default.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.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_1.default.Types.ObjectId(id);
+        const [callItems, callSummaryRows, sessionResult] = await Promise.all([
+            // Q1: Paginated calls
+            call_model_1.default.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_model_1.default.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
+            whatsapp_chat_model_1.default.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('/tenants/:id/sync-whatsapp-costs', async (request, reply) => {
+        const { id } = request.params;
+        const tenant = await tenant_model_1.default.findById(id).lean();
+        if (!tenant) {
+            return reply.status(404).send({ error: 'Tenant not found' });
+        }
+        const sessions = await whatsapp_session_model_1.default.find({
+            tenant_id: new mongoose_1.default.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 elevenlabs_service_1.default.getConversation(session.elevenlabs_conversation_id);
+                const cost = conv.metadata?.cost;
+                if (cost != null) {
+                    await whatsapp_session_model_1.default.updateOne({ _id: session._id }, { elevenlabs_cost: cost });
+                    updated++;
+                }
+            }
+            catch (err) {
+                const status = err.statusCode
+                    || err.status;
+                if (status === 404) {
+                    await whatsapp_session_model_1.default.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;
+        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_model_1.default.findById(tenant_id);
+        if (!tenant) {
+            return reply.status(404).send({ error: 'Tenant not found' });
+        }
+        // Lookup plan name from slug
+        const plan = await plan_model_1.default.findOne({ slug: plan_slug }).lean();
+        const plan_name = paymentType === 'top_up'
+            ? `Ek Dakika (${extra_minutes} dk)`
+            : (plan?.name || plan_slug);
+        const user = request.user;
+        const payment = await payment_model_1.default.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_model_1.default.findOne({
+                tenant_id,
+                type: 'subscription',
+                _id: { $ne: payment._id },
+                period_end: { $lt: now },
+            }).sort({ period_end: -1 }).lean();
+            if (prevPayment) {
+                (0, billing_service_1.snapshotPeriod)(tenant_id, prevPayment.period_start, prevPayment.period_end, prevPayment._id.toString())
+                    .catch(err => logger_1.default.error('Failed to snapshot billing period', { error: err.message }));
+            }
+        }
+        return reply.status(201).send({ payment });
+    });
+    // ─── ElevenLabs API (read-only proxies) ───────────────────
+    // GET /admin/elevenlabs/agents — list ElevenLabs agents
+    fastify.get('/elevenlabs/agents', async (request) => {
+        const { page_size, search, cursor } = request.query;
+        return elevenlabs_service_1.default.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('/elevenlabs/agents/:agentId', async (request) => {
+        const { agentId } = request.params;
+        return elevenlabs_service_1.default.getAgent(agentId);
+    });
+    // GET /admin/elevenlabs/conversations — list conversations
+    fastify.get('/elevenlabs/conversations', async (request) => {
+        const { agent_id, page_size, cursor, call_successful, search } = request.query;
+        return elevenlabs_service_1.default.listConversations({
+            agentId: agent_id || undefined,
+            pageSize: page_size ? parseInt(page_size, 10) : undefined,
+            cursor: cursor || undefined,
+            callSuccessful: call_successful,
+            search: search || undefined,
+        });
+    });
+    // GET /admin/elevenlabs/conversations/:conversationId — get conversation detail
+    fastify.get('/elevenlabs/conversations/:conversationId', async (request) => {
+        const { conversationId } = request.params;
+        return elevenlabs_service_1.default.getConversation(conversationId);
+    });
+    // GET /admin/elevenlabs/conversations/review — enriched list with evaluation status
+    fastify.get('/elevenlabs/conversations/review', async (request) => {
+        const { agent_id, page_size, cursor, call_successful } = request.query;
+        const currentUser = request.user;
+        // Get all active claims by OTHER users (exclude our own claims)
+        const otherClaims = await ConversationClaim_1.default.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 = [];
+        let currentCursor = cursor || undefined;
+        let hasMore = true;
+        let nextCursor;
+        // Keep fetching pages until we have enough non-text conversations or run out
+        while (results.length < targetSize && hasMore) {
+            const listResult = await elevenlabs_service_1.default.listConversations({
+                agentId: agent_id || undefined,
+                pageSize: 25, // fetch in chunks of 25
+                cursor: currentCursor,
+                callSuccessful: call_successful,
+            });
+            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_1.default.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 elevenlabs_service_1.default.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.externalNumber : null,
+                        agentNumber: phoneCall ? phoneCall.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('/elevenlabs/conversations/:conversationId/audio', async (request, reply) => {
+        const { conversationId } = request.params;
+        try {
+            const audioResult = await elevenlabs_service_1.default.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 = stream_1.Readable.fromWeb(audioResult);
+                return reply.send(nodeStream);
+            }
+            else if (Buffer.isBuffer(audioResult)) {
+                return reply.send(audioResult);
+            }
+            else if (audioResult && typeof audioResult.pipe === 'function') {
+                // Already a Node.js Readable stream
+                return reply.send(audioResult);
+            }
+            else if (audioResult && typeof audioResult[Symbol.asyncIterator] === 'function') {
+                // Async iterable
+                const chunks = [];
+                for await (const chunk of audioResult) {
+                    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);
+            }
+        }
+        catch (error) {
+            logger_1.default.error('Failed to stream conversation audio', { conversationId, error: error.message });
+            return reply.status(500).send({ error: 'Audio yuklenemedi' });
+        }
+    });
+    // GET /admin/elevenlabs/evaluations — list all evaluations with pagination
+    fastify.get('/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 = {};
+        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 || {}), $gte: parseFloat(min_score) };
+        if (max_score)
+            filter.overall_score = { ...(filter.overall_score || {}), $lte: parseFloat(max_score) };
+        const [rawEvaluations, total] = await Promise.all([
+            ConversationEvaluation_1.default.find(filter).sort({ createdAt: -1 }).skip(skip).limit(limitNum).lean(),
+            ConversationEvaluation_1.default.countDocuments(filter),
+        ]);
+        // Enrich evaluations with conversation details from ElevenLabs
+        const evaluations = await Promise.all(rawEvaluations.map(async (ev) => {
+            try {
+                const detail = await elevenlabs_service_1.default.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.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_1.default.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_1.default.countDocuments({ skipped: true });
+        // Per-evaluator stats
+        const evaluatorStats = await ConversationEvaluation_1.default.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('/elevenlabs/conversations/:conversationId/evaluation', async (request, reply) => {
+        const { conversationId } = request.params;
+        const evaluation = await ConversationEvaluation_1.default.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('/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;
+        const dbUser = await auth_model_1.default.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_1.default.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('/elevenlabs/conversations/:conversationId/evaluation', async (request, reply) => {
+        const { conversationId } = request.params;
+        const result = await ConversationEvaluation_1.default.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('/elevenlabs/conversations/:conversationId/claim', async (request) => {
+        const { conversationId } = request.params;
+        const jwtUser = request.user;
+        const dbUser = await auth_model_1.default.findById(jwtUser.id).select('name').lean();
+        await ConversationClaim_1.default.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('/elevenlabs/conversations/:conversationId/skip', async (request) => {
+        const { conversationId } = request.params;
+        const jwtUser = request.user;
+        const dbUser = await auth_model_1.default.findById(jwtUser.id).select('name').lean();
+        const evaluatorName = dbUser?.name || 'Superadmin';
+        const evaluation = await ConversationEvaluation_1.default.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('/elevenlabs/inbound-calls', async (request) => {
+        const { agent_id, page_size, cursor, call_successful, search } = request.query;
+        const listResult = await elevenlabs_service_1.default.listConversations({
+            agentId: agent_id || undefined,
+            pageSize: page_size ? parseInt(page_size, 10) : undefined,
+            cursor: cursor || undefined,
+            callSuccessful: call_successful,
+            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 elevenlabs_service_1.default.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.type : null,
+                    callSid: phoneCall ? phoneCall.callSid : null,
+                    agentNumber: phoneCall ? phoneCall.agentNumber : null,
+                    externalNumber: phoneCall ? phoneCall.externalNumber : null,
+                    phoneNumberId: phoneCall ? phoneCall.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('/elevenlabs/batch-calls', async (request) => {
+        const { limit, last_doc } = request.query;
+        return elevenlabs_service_1.default.listBatchCalls({
+            limit: limit ? parseInt(limit, 10) : undefined,
+            lastDoc: last_doc || undefined,
+        });
+    });
+    // GET /admin/elevenlabs/batch-calls/:batchId — get batch call detail
+    fastify.get('/elevenlabs/batch-calls/:batchId', async (request) => {
+        const { batchId } = request.params;
+        return elevenlabs_service_1.default.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;
+        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 elevenlabs_service_1.default.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 elevenlabs_service_1.default.listWebhooks({ includeUsages: true });
+    });
+    // POST /admin/elevenlabs/webhooks — create workspace webhook
+    fastify.post('/elevenlabs/webhooks', async (request, reply) => {
+        const { name, webhookUrl } = request.body;
+        if (!name || !webhookUrl) {
+            return reply.status(400).send({ error: 'name and webhookUrl are required' });
+        }
+        return elevenlabs_service_1.default.createWebhook({
+            settings: { authType: 'hmac', name, webhookUrl },
+        });
+    });
+    // PATCH /admin/elevenlabs/webhooks/:webhookId — update webhook
+    fastify.patch('/elevenlabs/webhooks/:webhookId', async (request) => {
+        const { webhookId } = request.params;
+        const { isDisabled, name } = request.body;
+        return elevenlabs_service_1.default.updateWebhook(webhookId, {
+            isDisabled: isDisabled ?? false,
+            name: name ?? '',
+        });
+    });
+    // DELETE /admin/elevenlabs/webhooks/:webhookId — delete webhook
+    fastify.delete('/elevenlabs/webhooks/:webhookId', async (request) => {
+        const { webhookId } = request.params;
+        return elevenlabs_service_1.default.deleteWebhook(webhookId);
+    });
+    // PATCH /admin/elevenlabs/agents/:agentId/webhook — assign post-call webhook to agent
+    fastify.patch('/elevenlabs/agents/:agentId/webhook', async (request, reply) => {
+        const { agentId } = request.params;
+        const { postCallWebhookId, events } = request.body;
+        if (!postCallWebhookId) {
+            return reply.status(400).send({ error: 'postCallWebhookId is required' });
+        }
+        return elevenlabs_service_1.default.updateAgent(agentId, {
+            platformSettings: {
+                workspaceOverrides: {
+                    webhooks: {
+                        postCallWebhookId,
+                        events: events || ['transcript'],
+                    },
+                },
+            },
+        });
+    });
+    // DELETE /admin/elevenlabs/agents/:agentId/webhook — remove post-call webhook from agent
+    fastify.delete('/elevenlabs/agents/:agentId/webhook', async (request) => {
+        const { agentId } = request.params;
+        return elevenlabs_service_1.default.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 Promise.resolve().then(() => __importStar(require('../../services/unipile.service')))).default;
+        return { providers: unipileService.getAvailableProviders() };
+    });
+    // PUT /admin/tenants/:id/whatsapp-bridge — Set tenant's bridge provider
+    fastify.put('/tenants/:id/whatsapp-bridge', async (request, reply) => {
+        const { id } = request.params;
+        const { provider } = request.body;
+        if (!['unipile', 'baileys'].includes(provider)) {
+            return reply.status(400).send({ error: 'Invalid provider. Must be "unipile" or "baileys"' });
+        }
+        const unipileService = (await Promise.resolve().then(() => __importStar(require('../../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_model_1.default.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_model_1.default.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('/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 = {};
+        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 = {};
+            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_model_1.default.find(filter).sort({ createdAt: -1 }).skip(skip).limit(limit).lean(),
+            lead_model_1.default.countDocuments(filter)
+        ]);
+        // Enrich with tenant names
+        const tenantIds = [...new Set(leads.map(l => String(l.tenant_id)))];
+        const tenants = await tenant_model_1.default.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_model_1.default.countDocuments({ lead_status: { $ne: 'expired' } }),
+            lead_model_1.default.aggregate([
+                { $match: { lead_status: { $ne: 'expired' } } },
+                { $group: { _id: '$lead_status', count: { $sum: 1 } } }
+            ]),
+            lead_model_1.default.aggregate([
+                { $match: { lead_status: { $ne: 'expired' } } },
+                { $group: { _id: '$channel', count: { $sum: 1 } } }
+            ])
+        ]);
+        const statusMap = {};
+        for (const s of byStatus)
+            statusMap[s._id] = s.count;
+        const channelMap = {};
+        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([
+            whatsapp_chat_model_1.default.countDocuments({ deleted_at: null }),
+            whatsapp_chat_model_1.default.countDocuments({ is_closed: true, deleted_at: null }),
+            whatsapp_session_model_1.default.countDocuments({ status: 'waiting' }),
+            whatsapp_session_model_1.default.countDocuments({ status: 'active' }),
+            whatsapp_message_model_1.default.countDocuments(),
+        ]);
+        const humanTakeoverCount = await whatsapp_session_model_1.default.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_model_1.default.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_model_1.default.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('/whatsapp/contact-profiles', async (request) => {
+        const limit = Math.min(parseInt(request.query.limit || '50', 10), 100);
+        const search = request.query.search?.trim();
+        const filter = {};
+        if (search) {
+            filter.$or = [
+                { display_name: { $regex: search, $options: 'i' } },
+                { phone: { $regex: search, $options: 'i' } },
+            ];
+        }
+        const profiles = await whatsapp_contact_profile_model_1.default.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('/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 = { deleted_at: null };
+        if (request.query.tenant_id) {
+            filter.tenant_id = new mongoose_1.default.Types.ObjectId(request.query.tenant_id);
+        }
+        const pipeline = [
+            { $match: filter },
+            { $sort: { last_message_at: -1 } },
+            {
+                $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 whatsapp_chat_model_1.default.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('/whatsapp/chats/:chatId', async (request, reply) => {
+        const { chatId } = request.params;
+        const chat = await whatsapp_chat_model_1.default.findById(chatId).lean();
+        if (!chat)
+            return reply.status(404).send({ error: 'Chat not found' });
+        const tenant = await tenant_model_1.default.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('/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 whatsapp_chat_model_1.default.findById(chatId);
+        if (!chat)
+            return reply.status(404).send({ error: 'Chat not found' });
+        const [messages, total] = await Promise.all([
+            whatsapp_message_model_1.default.find({ chat_id: chatId })
+                .sort({ createdAt: 1 })
+                .skip(skip)
+                .limit(limit)
+                .lean(),
+            whatsapp_message_model_1.default.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('/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 whatsapp_chat_model_1.default.findById(chatId);
+        if (!chat)
+            return reply.status(404).send({ error: 'Chat not found' });
+        const [sessions, total] = await Promise.all([
+            whatsapp_session_model_1.default.find({ chat_id: chatId })
+                .populate('taken_over_by', 'name email')
+                .sort({ started_at: -1 })
+                .skip(skip)
+                .limit(limit)
+                .lean(),
+            whatsapp_session_model_1.default.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('/whatsapp/chats/:chatId', async (request, reply) => {
+        const { chatId } = request.params;
+        const chat = await whatsapp_chat_model_1.default.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) {
+            whatsapp_agent_service_1.default.closeConnection(chat.unipile_chat_id);
+        }
+        if (chat.active_session_id) {
+            whatsapp_agent_service_1.default.cancelSession(chat.active_session_id.toString());
+        }
+        // 2. Hard-delete all related documents
+        const [msgResult, sessResult] = await Promise.all([
+            whatsapp_message_model_1.default.deleteMany({ chat_id: chatId }),
+            whatsapp_session_model_1.default.deleteMany({ chat_id: chatId }),
+        ]);
+        // 3. Delete linked contact profile
+        let profileDeleted = 0;
+        if (chat.contact_profile_id) {
+            const res = await whatsapp_contact_profile_model_1.default.deleteOne({ _id: chat.contact_profile_id });
+            profileDeleted = res.deletedCount;
+        }
+        // 4. Hard-delete the chat itself
+        await whatsapp_chat_model_1.default.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('/whatsapp/grace-period', async (request, reply) => {
+        const body = request.body;
+        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_model_1.default.findByIdAndUpdate(new mongoose_1.default.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('/whatsapp/chats/:chatId/force-resolve', async (request, reply) => {
+        const { chatId } = request.params;
+        const chat = await whatsapp_chat_model_1.default.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 whatsapp_session_model_1.default.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)
+        whatsapp_agent_service_1.default.cancelSession(session._id.toString());
+        // Close ElevenLabs WebSocket connection
+        whatsapp_agent_service_1.default.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
+        whatsapp_agent_service_1.default.updateContactProfileSummary(session._id.toString()).catch(err => {
+            fastify.log.error({ error: err.message }, 'Profile summary update failed after force-resolve');
+        });
+        whatsapp_agent_service_1.default.generateSessionLabels(session._id.toString()).catch(err => {
+            fastify.log.error({ error: err.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_model_1.default.find({ 'settings.whatsapp_agent.unipile_account_id': { $ne: null } }, { name: 1, 'settings.whatsapp_agent.unipile_account_id': 1 }).lean();
+        const map = new Map();
+        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('/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_1.default.connection.db;
+        if (!db)
+            return { logs: [], total: 0, page, totalPages: 0 };
+        const accountMap = await buildAccountTenantMap();
+        const filter = {};
+        // Filter by tenant → find matching accountId
+        if (request.query.tenant_id) {
+            const accountIds = [];
+            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 = {};
+            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('/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_1.default.connection.db;
+        if (!db)
+            return { logs: [], total: 0, page, totalPages: 0 };
+        const accountMap = await buildAccountTenantMap();
+        const filter = {};
+        if (request.query.tenant_id) {
+            const accountIds = [];
+            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 = {};
+            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_1.default.connection.db;
+        if (!db)
+            return { stats: {} };
+        const col = db.collection('baileys_message_log');
+        const pipeline = [
+            { $group: { _id: '$action', count: { $sum: 1 } } },
+            { $sort: { count: -1 } },
+        ];
+        const results = await col.aggregate(pipeline).toArray();
+        const stats = {};
+        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('/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_1.default.Types.ObjectId(request.query.tenant_id) }
+            : {};
+        const [waPerTenant, callPerTenant, waDailyRows, callDailyRows, tenantList, waDailyPerTenantRows, callDailyPerTenantRows] = await Promise.all([
+            // Q1: WA credits per tenant
+            whatsapp_session_model_1.default.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_model_1.default.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
+            whatsapp_session_model_1.default.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_model_1.default.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_model_1.default.find({}).select('name').lean(),
+            // Q6: WA daily trend per tenant
+            whatsapp_session_model_1.default.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_model_1.default.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();
+        for (const t of tenantList)
+            tenantMap.set(String(t._id), t.name);
+        // Merge per-tenant results
+        const perTenantMap = new Map();
+        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) => [r._id, r.wa]));
+        const callMap = new Map(callDailyRows.map((r) => [r._id, r.calls]));
+        const daily_trend = [];
+        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();
+        const waPTMap = new Map(); // date -> tenantId -> credits
+        const callPTMap = new Map();
+        for (const row of waDailyPerTenantRows) {
+            const { date, tenant_id } = row._id;
+            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;
+            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 = [];
+        const call_daily_per_tenant = [];
+        const c2 = new Date(from);
+        c2.setHours(0, 0, 0, 0);
+        while (c2 <= endDate) {
+            const key = c2.toISOString().slice(0, 10);
+            const waDay = { date: key };
+            const callDay = { 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 })),
+        };
+    });
+}
+//# sourceMappingURL=admin.routes.js.map