elevenlabs-webhook-nodejs 1.0.0

package/dist/services/whatsapp-agent.service.js

@@ -0,0 +1,2055 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const mongoose_1 = __importDefault(require("mongoose"));
+const ws_1 = __importDefault(require("ws"));
+const elevenlabs_service_1 = __importDefault(require("./elevenlabs.service"));
+const unipile_service_1 = __importDefault(require("./unipile.service"));
+const whatsapp_chat_model_1 = __importDefault(require("../modules/whatsapp/whatsapp-chat.model"));
+const whatsapp_session_model_1 = __importDefault(require("../modules/whatsapp/whatsapp-session.model"));
+const whatsapp_message_model_1 = __importDefault(require("../modules/whatsapp/whatsapp-message.model"));
+const appointment_model_1 = __importDefault(require("../modules/whatsapp/appointment.model"));
+const tenant_model_1 = __importDefault(require("../modules/tenants/tenant.model"));
+const agent_model_1 = __importDefault(require("../modules/agents/agent.model"));
+const whatsapp_contact_profile_model_1 = __importDefault(require("../modules/whatsapp/whatsapp-contact-profile.model"));
+const operator_request_model_1 = __importDefault(require("../modules/whatsapp/operator-request.model"));
+const google_calendar_service_1 = __importDefault(require("./google-calendar.service"));
+const netgsm_service_1 = __importDefault(require("./netgsm.service"));
+const lead_model_1 = __importDefault(require("../modules/leads/lead.model"));
+const ai_1 = require("./ai");
+const openai_1 = __importDefault(require("openai"));
+const config_1 = __importDefault(require("../config"));
+const logger_1 = __importDefault(require("../utils/logger"));
+/**
+ * Resolve the active ElevenLabs agent ID for a tenant's WhatsApp agent.
+ * Returns the elevenlabs_agent_id string if the agent exists and is active, or '' otherwise.
+ */
+async function resolveAgentId(tenant) {
+    const agentObjId = tenant.settings?.whatsapp_agent?.agent_id;
+    if (!agentObjId)
+        return '';
+    const agent = await agent_model_1.default.findById(agentObjId).lean();
+    if (!agent || !agent.is_active)
+        return '';
+    return agent.elevenlabs_agent_id;
+}
+// Keepalive ping interval to prevent EL from dropping idle connections
+const WS_PING_INTERVAL_MS = 30_000;
+// Auto-resolve active sessions with no activity after this duration
+const SESSION_INACTIVITY_TIMEOUT_MS = 2 * 60 * 60 * 1000; // 2 hours
+// Wait this long after the last contact message before sending to AI (debounce)
+const MESSAGE_BUFFER_MIN_MS = 10_000; // 10 seconds
+const MESSAGE_BUFFER_MAX_MS = 50_000; // 50 seconds
+class WhatsAppAgentService {
+    connections = new Map(); // key: unipileChatId
+    sessionTimers = new Map(); // key: sessionId
+    messageBufferTimers = new Map(); // key: sessionId
+    idleTimeoutMs = 2 * 60 * 60 * 1000; // 2 hours (matches session inactivity timeout)
+    cleanupInterval = null;
+    sweepInterval = null;
+    inactivitySweepInterval = null;
+    costSweepInterval = null;
+    async initialize() {
+        this.cleanupInterval = setInterval(() => this.cleanupIdle(), 60_000);
+        this.sweepInterval = setInterval(() => {
+            this.sweepStuckSessions().catch(err => {
+                logger_1.default.error('Stuck session sweep failed', { error: err.message });
+            });
+        }, 5 * 60_000);
+        this.inactivitySweepInterval = setInterval(() => {
+            this.sweepInactiveSessions().catch(err => {
+                logger_1.default.error('Inactive session sweep failed', { error: err.message });
+            });
+        }, 5 * 60_000);
+        this.costSweepInterval = setInterval(() => {
+            this.sweepConversationCosts().catch(err => {
+                logger_1.default.error('Cost sweep failed', { error: err.message });
+            });
+        }, 10 * 60_000);
+        setInterval(() => {
+            this.sweepExpiredOperatorRequests().catch(err => {
+                logger_1.default.error('Operator request expiry sweep failed', { error: err.message });
+            });
+        }, 15 * 60_000);
+        await this.recoverSessions();
+        logger_1.default.info('WhatsAppAgentService initialized');
+    }
+    // ─── Session Management ──────────────────────────────────
+    async startSession(params) {
+        const { session, gracePeriodSeconds, agentId, tenantId } = params;
+        const sessionId = session._id.toString();
+        // Cancel any existing timer for this session
+        this.cancelSession(sessionId);
+        const timer = setTimeout(async () => {
+            this.sessionTimers.delete(sessionId);
+            await this.onGracePeriodExpired(sessionId, agentId, tenantId);
+        }, gracePeriodSeconds * 1000);
+        this.sessionTimers.set(sessionId, timer);
+        logger_1.default.info('Session grace period started', {
+            sessionId,
+            chatId: session.chat_id,
+            gracePeriodSeconds,
+            deadline: session.grace_deadline?.toISOString(),
+        });
+    }
+    cancelSession(sessionId) {
+        const timer = this.sessionTimers.get(sessionId);
+        if (timer) {
+            clearTimeout(timer);
+            this.sessionTimers.delete(sessionId);
+            logger_1.default.info('Session timer cancelled', { sessionId });
+        }
+        this.cancelMessageBuffer(sessionId);
+    }
+    cancelMessageBuffer(sessionId) {
+        const timer = this.messageBufferTimers.get(sessionId);
+        if (timer) {
+            clearTimeout(timer);
+            this.messageBufferTimers.delete(sessionId);
+            logger_1.default.debug('Message buffer timer cancelled', { sessionId });
+        }
+    }
+    async resolveSessionAsHuman(session) {
+        this.cancelSession(session._id.toString());
+        session.status = 'resolved';
+        session.resolved_by = 'human';
+        session.resolved_at = new Date();
+        await session.save();
+        await whatsapp_chat_model_1.default.updateOne({ _id: session.chat_id }, { active_session_id: null });
+        logger_1.default.info('Session resolved by human response', { sessionId: session._id });
+        this.updateContactProfileSummary(session._id.toString()).catch(err => {
+            logger_1.default.error('Profile summary update failed after human resolve', { error: err.message });
+        });
+        this.generateSessionLabels(session._id.toString()).catch(err => {
+            logger_1.default.error('Session labelling failed after human resolve', { error: err.message });
+        });
+    }
+    /**
+     * Find unanswered contact messages in a session and trigger AI response.
+     * Used by grace period expiry and the "immediate response" release option.
+     */
+    async replayPendingMessages(params) {
+        const { tenantId, agentId, session } = params;
+        const sessionId = session._id.toString();
+        // Skip AI if any human has ever messaged in this chat
+        if (await this.hasHumanMessageInChat(session.chat_id)) {
+            logger_1.default.info('Skipping AI replay — human has previously messaged in this chat', { sessionId });
+            return { pendingCount: 0 };
+        }
+        // Skip AI if outside shift hours
+        const tenant = await tenant_model_1.default.findById(tenantId).lean();
+        if (tenant && !this.isWithinAiShift(tenant)) {
+            logger_1.default.info('Skipping AI replay — outside AI shift hours', { sessionId });
+            return { pendingCount: 0 };
+        }
+        // Simple session-scoped query — no backwards scanning
+        const pendingMessages = await whatsapp_message_model_1.default.find({
+            session_id: session._id,
+            sender: 'contact',
+        }).sort({ createdAt: 1 }).lean();
+        if (pendingMessages.length === 0) {
+            logger_1.default.info('No pending messages to replay', { sessionId });
+            return { pendingCount: 0 };
+        }
+        const combinedText = pendingMessages.map(m => m.text).join('\n');
+        logger_1.default.info('Replaying pending messages for AI response', {
+            sessionId,
+            messageCount: pendingMessages.length,
+        });
+        const chat = await whatsapp_chat_model_1.default.findById(session.chat_id);
+        if (!chat)
+            return { pendingCount: 0 };
+        await this.triggerAiResponse({
+            tenantId,
+            agentId,
+            chat,
+            session,
+            messageText: combinedText,
+        });
+        return { pendingCount: pendingMessages.length };
+    }
+    /**
+     * Called when the message buffer timer expires (20s after last contact message).
+     * Collects all unanswered contact messages and sends them combined to AI.
+     */
+    async onMessageBufferExpired(sessionId, tenantId, agentId) {
+        this.messageBufferTimers.delete(sessionId);
+        const session = await whatsapp_session_model_1.default.findById(sessionId);
+        if (!session || session.status !== 'active' || session.taken_over_by) {
+            logger_1.default.debug('Buffer expired but session not active for AI', { sessionId });
+            return;
+        }
+        const chat = await whatsapp_chat_model_1.default.findById(session.chat_id);
+        if (!chat)
+            return;
+        // Skip AI if any human has ever messaged in this chat
+        if (await this.hasHumanMessageInChat(session.chat_id)) {
+            logger_1.default.info('Buffer expired but skipping AI — human has previously messaged', { sessionId });
+            return;
+        }
+        // Skip AI if outside shift hours
+        const tenant = await tenant_model_1.default.findById(session.tenant_id).lean();
+        if (tenant && !this.isWithinAiShift(tenant)) {
+            logger_1.default.info('Buffer expired but outside AI shift hours — skipping AI', { sessionId });
+            return;
+        }
+        // Find the last AI response in this session
+        const lastAiMsg = await whatsapp_message_model_1.default.findOne({
+            session_id: session._id,
+            sender: 'human',
+            sender_name: 'AI',
+        }).sort({ createdAt: -1 }).lean();
+        // Get all contact messages after the last AI response (or all if no AI response yet)
+        const query = {
+            session_id: session._id,
+            sender: 'contact',
+        };
+        if (lastAiMsg) {
+            query.createdAt = { $gt: lastAiMsg.createdAt };
+        }
+        const pendingMessages = await whatsapp_message_model_1.default.find(query).sort({ createdAt: 1 }).lean();
+        if (pendingMessages.length === 0) {
+            logger_1.default.debug('Buffer expired but no pending messages', { sessionId });
+            return;
+        }
+        const combinedText = pendingMessages.map(m => m.text).join('\n');
+        logger_1.default.info('Message buffer expired, sending combined message to AI', {
+            sessionId,
+            messageCount: pendingMessages.length,
+            combinedLength: combinedText.length,
+        });
+        await this.triggerAiResponse({
+            tenantId,
+            agentId,
+            chat,
+            session,
+            messageText: combinedText,
+        });
+    }
+    async onGracePeriodExpired(sessionId, agentId, tenantId) {
+        const session = await whatsapp_session_model_1.default.findById(sessionId);
+        if (!session)
+            return;
+        if (session.status !== 'waiting') {
+            logger_1.default.info('Grace period expired but session already resolved', {
+                sessionId,
+                status: session.status,
+            });
+            return;
+        }
+        if (!agentId) {
+            session.status = 'resolved';
+            session.resolved_by = 'manual';
+            session.resolved_at = new Date();
+            await session.save();
+            await whatsapp_chat_model_1.default.updateOne({ _id: session.chat_id }, { active_session_id: null });
+            logger_1.default.info('Grace period expired but no agent configured', { sessionId });
+            return;
+        }
+        // Skip AI if any human has ever messaged in this chat
+        if (await this.hasHumanMessageInChat(session.chat_id)) {
+            session.status = 'resolved';
+            session.resolved_by = 'manual';
+            session.resolved_at = new Date();
+            await session.save();
+            await whatsapp_chat_model_1.default.updateOne({ _id: session.chat_id }, { active_session_id: null });
+            logger_1.default.info('Grace period expired but skipping AI — human has previously messaged', { sessionId });
+            return;
+        }
+        // Skip AI if outside shift hours
+        const tenant = await tenant_model_1.default.findById(tenantId).lean();
+        if (tenant && !this.isWithinAiShift(tenant)) {
+            session.status = 'resolved';
+            session.resolved_by = 'manual';
+            session.resolved_at = new Date();
+            await session.save();
+            await whatsapp_chat_model_1.default.updateOne({ _id: session.chat_id }, { active_session_id: null });
+            logger_1.default.info('Grace period expired but outside AI shift hours — resolved as manual', { sessionId });
+            return;
+        }
+        // Transition to active (AI takes over)
+        session.status = 'active';
+        await session.save();
+        logger_1.default.info('Grace period expired, session now active (AI)', { sessionId, agentId });
+        await this.replayPendingMessages({ tenantId, agentId, session });
+    }
+    async recoverSessions() {
+        const waitingSessions = await whatsapp_session_model_1.default.find({ status: 'waiting' }).lean();
+        const now = Date.now();
+        for (const session of waitingSessions) {
+            const deadline = session.grace_deadline
+                ? new Date(session.grace_deadline).getTime()
+                : 0;
+            const remaining = deadline - now;
+            const tenant = await tenant_model_1.default.findById(session.tenant_id).lean();
+            const agentId = tenant ? await resolveAgentId(tenant) : '';
+            const sessionId = session._id.toString();
+            if (remaining <= 0) {
+                logger_1.default.info('Recovering expired session', { sessionId });
+                await this.onGracePeriodExpired(sessionId, agentId, session.tenant_id.toString());
+            }
+            else {
+                logger_1.default.info('Recovering active session', { sessionId, remainingMs: remaining });
+                const timer = setTimeout(async () => {
+                    this.sessionTimers.delete(sessionId);
+                    await this.onGracePeriodExpired(sessionId, agentId, session.tenant_id.toString());
+                }, remaining);
+                this.sessionTimers.set(sessionId, timer);
+            }
+        }
+        if (waitingSessions.length > 0) {
+            logger_1.default.info('Session recovery complete', { recovered: waitingSessions.length });
+        }
+    }
+    /**
+     * Safety net: find sessions stuck in 'waiting' past their deadline
+     * that no longer have an in-memory timer.
+     */
+    async sweepStuckSessions() {
+        const stuckSessions = await whatsapp_session_model_1.default.find({
+            status: 'waiting',
+            grace_deadline: { $lt: new Date() },
+        }).lean();
+        let swept = 0;
+        for (const session of stuckSessions) {
+            const sessionId = session._id.toString();
+            if (this.sessionTimers.has(sessionId))
+                continue;
+            swept++;
+            logger_1.default.warn('Sweeping stuck session', {
+                sessionId,
+                deadline: session.grace_deadline,
+            });
+            const tenant = await tenant_model_1.default.findById(session.tenant_id).lean();
+            const agentId = tenant ? await resolveAgentId(tenant) : '';
+            await this.onGracePeriodExpired(sessionId, agentId, session.tenant_id.toString());
+        }
+        if (swept > 0) {
+            logger_1.default.info('Stuck session sweep complete', { swept, total: stuckSessions.length });
+        }
+    }
+    /**
+     * Auto-resolve active sessions that have had no activity for SESSION_INACTIVITY_TIMEOUT_MS.
+     * Uses updatedAt as the activity indicator (updated on every message count increment).
+     */
+    async sweepInactiveSessions() {
+        const cutoff = new Date(Date.now() - SESSION_INACTIVITY_TIMEOUT_MS);
+        const inactiveSessions = await whatsapp_session_model_1.default.find({
+            status: 'active',
+            awaiting_operator: { $ne: true },
+            updatedAt: { $lt: cutoff },
+        }).lean();
+        let resolved = 0;
+        for (const session of inactiveSessions) {
+            const sessionId = session._id.toString();
+            // Close the WS connection if still open
+            const chat = await whatsapp_chat_model_1.default.findById(session.chat_id);
+            if (chat) {
+                this.closeConnection(chat.unipile_chat_id);
+            }
+            // Resolve the session
+            await whatsapp_session_model_1.default.updateOne({ _id: session._id }, {
+                status: 'resolved',
+                resolved_by: 'timeout',
+                resolved_at: new Date(),
+            });
+            // Unlink from chat
+            await whatsapp_chat_model_1.default.updateOne({ _id: session.chat_id, active_session_id: session._id }, { active_session_id: null });
+            resolved++;
+            logger_1.default.info('Auto-resolved inactive session', {
+                sessionId,
+                chatId: session.chat_id,
+                lastActivity: session.updatedAt,
+            });
+            this.updateContactProfileSummary(sessionId).catch(err => {
+                logger_1.default.error('Profile summary update failed after inactive sweep', { error: err.message });
+            });
+            this.generateSessionLabels(sessionId).catch(err => {
+                logger_1.default.error('Session labelling failed after inactive sweep', { error: err.message });
+            });
+        }
+        if (resolved > 0) {
+            logger_1.default.info('Inactive session sweep complete', { resolved, total: inactiveSessions.length });
+        }
+    }
+    /**
+     * Fetch ElevenLabs credits for resolved sessions that have a conversation ID but no cost yet.
+     */
+    async sweepConversationCosts() {
+        const sessions = await whatsapp_session_model_1.default.find({
+            elevenlabs_conversation_id: { $ne: null },
+            elevenlabs_cost: null,
+            status: 'resolved',
+        }).limit(20).lean();
+        let updated = 0;
+        for (const session of sessions) {
+            try {
+                const conv = await elevenlabs_service_1.default.getConversation(session.elevenlabs_conversation_id);
+                const convAny = conv;
+                const cost = convAny.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 });
+                    logger_1.default.warn('Conversation not found on ElevenLabs, set cost to 0', {
+                        sessionId: session._id,
+                        conversationId: session.elevenlabs_conversation_id,
+                    });
+                }
+                else {
+                    logger_1.default.warn('Failed to fetch conversation cost', {
+                        sessionId: session._id,
+                        conversationId: session.elevenlabs_conversation_id,
+                        error: err.message,
+                    });
+                }
+            }
+        }
+        if (updated > 0) {
+            logger_1.default.info('Conversation cost sweep complete', { updated, checked: sessions.length });
+        }
+    }
+    // ─── AI Condition Checks ─────────────────────────────────
+    /**
+     * Check if any real human (not AI bot) has ever sent a message in this chat.
+     * Used to permanently skip AI for chats where a human has already engaged.
+     */
+    async hasHumanMessageInChat(chatId) {
+        const msg = await whatsapp_message_model_1.default.findOne({
+            chat_id: chatId,
+            sender: 'human',
+            sender_name: { $ne: 'AI' },
+        }).select('_id').lean();
+        return !!msg;
+    }
+    /**
+     * Check whether the AI agent should be active right now.
+     * The schedule represents **clinic working hours** (when humans handle messages).
+     * The AI is active OUTSIDE those hours.
+     * If shift is not enabled, returns true (AI works 24/7).
+     * Fixed timezone: Europe/Istanbul.
+     */
+    isWithinAiShift(tenant) {
+        const shift = tenant.settings?.whatsapp_agent;
+        if (!shift?.ai_shift_enabled)
+            return true;
+        const now = new Date();
+        // Get current hour, minute and day in Europe/Istanbul
+        const parts = new Intl.DateTimeFormat('en-US', {
+            timeZone: 'Europe/Istanbul',
+            hour: '2-digit',
+            minute: '2-digit',
+            hour12: false,
+        }).formatToParts(now);
+        const hour = parseInt(parts.find(p => p.type === 'hour')?.value || '0', 10);
+        const minute = parseInt(parts.find(p => p.type === 'minute')?.value || '0', 10);
+        const dayName = new Intl.DateTimeFormat('en-US', {
+            timeZone: 'Europe/Istanbul',
+            weekday: 'long',
+        }).format(now);
+        const dayMap = {
+            Sunday: 0, Monday: 1, Tuesday: 2, Wednesday: 3,
+            Thursday: 4, Friday: 5, Saturday: 6,
+        };
+        const currentDay = dayMap[dayName] ?? now.getDay();
+        // Per-day schedule with legacy fallback
+        // Schedule entries = clinic working hours (AI should be OFF during these)
+        const schedule = shift.ai_shift_schedule?.length
+            ? shift.ai_shift_schedule
+            : (shift.ai_shift_days || []).map(day => ({
+                day, start: shift.ai_shift_start || '09:00', end: shift.ai_shift_end || '18:00',
+            }));
+        // No clinic hours defined for today → AI active all day
+        const entry = schedule.find(e => e.day === currentDay);
+        if (!entry)
+            return true;
+        // Check if current time is within clinic hours
+        const currentMinutes = hour * 60 + minute;
+        const [startH, startM] = (entry.start || '09:00').split(':').map(Number);
+        const [endH, endM] = (entry.end || '18:00').split(':').map(Number);
+        const startMinutes = startH * 60 + startM;
+        const endMinutes = endH * 60 + endM;
+        let withinClinicHours;
+        if (startMinutes <= endMinutes) {
+            withinClinicHours = currentMinutes >= startMinutes && currentMinutes < endMinutes;
+        }
+        else {
+            // Overnight clinic hours (e.g. 22:00-06:00)
+            withinClinicHours = currentMinutes >= startMinutes || currentMinutes < endMinutes;
+        }
+        // AI is active when clinic is CLOSED
+        return !withinClinicHours;
+    }
+    // ─── AI Response ──────────────────────────────────────────
+    /**
+     * Build conversation context from current session messages only.
+     * Contact profile info is now sent via dynamic_variables at connection time.
+     */
+    async buildChatContext(chatId, currentSessionId) {
+        const messages = await whatsapp_message_model_1.default.find({ session_id: currentSessionId })
+            .sort({ createdAt: 1 })
+            .lean();
+        if (messages.length === 0)
+            return null;
+        // Also fetch operator requests for this session to weave into timeline
+        const operatorRequests = await operator_request_model_1.default.find({ session_id: currentSessionId })
+            .sort({ createdAt: 1 })
+            .lean();
+        const timeline = [];
+        for (const m of messages) {
+            const role = m.sender === 'contact' ? 'Patient' : 'Operator';
+            timeline.push({ at: m.createdAt, text: `${role}: ${m.text}` });
+        }
+        for (const req of operatorRequests) {
+            const mediaCount = req.forwarded_count || 1;
+            const failInfo = req.failed_count ? ` (${req.failed_count} iletilemedi)` : '';
+            timeline.push({
+                at: req.forwarded_at,
+                text: `[SİSTEM: Hastanın ${mediaCount} medyası doktora iletildi — Ref: ${req.ref_code}${failInfo}]`,
+            });
+            if (req.status === 'responded' && req.operator_response) {
+                timeline.push({
+                    at: req.responded_at || req.updatedAt,
+                    text: `[SİSTEM: Doktor yanıt verdi — Ref: ${req.ref_code}: "${req.operator_response}"]`,
+                });
+            }
+            else if (req.status === 'expired') {
+                timeline.push({
+                    at: req.updatedAt,
+                    text: `[SİSTEM: Doktordan yanıt alınamadı — Ref: ${req.ref_code} süresi doldu]`,
+                });
+            }
+        }
+        // Sort by timestamp
+        timeline.sort((a, b) => new Date(a.at).getTime() - new Date(b.at).getTime());
+        const lines = timeline.map(e => e.text);
+        // Check first contact message for ad context (patient clicked an ad to start the chat)
+        const firstContactMsg = messages.find(m => m.sender === 'contact');
+        const adCtx = firstContactMsg?.ad_context;
+        if (adCtx) {
+            const adParts = [];
+            if (adCtx.ad?.title)
+                adParts.push(`Reklam başlığı: ${adCtx.ad.title}`);
+            if (adCtx.ad?.body)
+                adParts.push(`Reklam içeriği: ${adCtx.ad.body}`);
+            if (adCtx.source)
+                adParts.push(`Kaynak: ${adCtx.source}`);
+            if (adCtx.app)
+                adParts.push(`Platform: ${adCtx.app}`);
+            if (adCtx.ad?.source_url)
+                adParts.push(`Reklam URL: ${adCtx.ad.source_url}`);
+            if (adParts.length > 0) {
+                lines.unshift(`[SİSTEM: Hasta şu reklama tıklayarak WhatsApp'a geldi]\n${adParts.join('\n')}`);
+            }
+        }
+        return `Current conversation:\n${lines.join('\n')}`;
+    }
+    async sendChatContext(conn, chatId, sessionId) {
+        const context = await this.buildChatContext(chatId, sessionId);
+        if (!context)
+            return;
+        conn.ws.send(JSON.stringify({
+            type: 'contextual_update',
+            text: context,
+        }));
+        logger_1.default.info('Sent chat history context to ElevenLabs', {
+            sessionId,
+            chatId,
+            contextLength: context.length,
+        });
+    }
+    async triggerAiResponse(params) {
+        const { agentId, chat, session, messageText } = params;
+        const unipileChatId = chat.unipile_chat_id;
+        const sessionId = session._id.toString();
+        let conn = this.connections.get(unipileChatId);
+        const isAlive = conn && conn.ws.readyState === ws_1.default.OPEN && conn.ready;
+        let isNewConnection = false;
+        let isReconnect = false;
+        if (!isAlive) {
+            if (conn) {
+                if (conn.pingTimer) {
+                    clearInterval(conn.pingTimer);
+                    conn.pingTimer = null;
+                }
+                conn.intentionallyClosed = true;
+                try {
+                    conn.ws.close();
+                }
+                catch { /* ignore */ }
+                this.connections.delete(unipileChatId);
+            }
+            // Detect reconnection: session already had an ElevenLabs conversation
+            isReconnect = !!session.elevenlabs_conversation_id;
+            try {
+                conn = await this.createConnection(agentId, chat, session, { isReconnect });
+                this.connections.set(unipileChatId, conn);
+                isNewConnection = true;
+            }
+            catch (err) {
+                logger_1.default.error('Failed to create EL connection', {
+                    error: err.message,
+                    unipileChatId,
+                    sessionId,
+                });
+                return;
+            }
+        }
+        conn.lastActivity = Date.now();
+        await whatsapp_session_model_1.default.updateOne({ _id: session._id }, { elevenlabs_last_interaction_at: new Date() });
+        // Send chat context via contextual_update for new connections
+        // (On reconnection with continuation enabled, this is redundant but harmless as backup)
+        if (isNewConnection) {
+            await this.sendChatContext(conn, chat._id.toString(), sessionId);
+        }
+        conn.ws.send(JSON.stringify({
+            type: 'user_message',
+            text: messageText,
+        }));
+        logger_1.default.info('AI triggered', { sessionId, text: messageText.substring(0, 50) });
+    }
+    async handleIncomingMessage(params) {
+        const { tenantId, agentId, chat, session, messageText, senderName, unipileMessageId, contentType } = params;
+        const unipileChatId = chat.unipile_chat_id;
+        const sessionId = session._id.toString();
+        // Store the incoming message with session_id
+        await whatsapp_message_model_1.default.create({
+            chat_id: chat._id,
+            session_id: session._id,
+            tenant_id: tenantId,
+            unipile_message_id: unipileMessageId || null,
+            sender: 'contact',
+            sender_name: senderName,
+            text: messageText,
+            media_type: contentType || null,
+            sent_via_unipile: false,
+        });
+        // Update chat + session metadata
+        chat.last_message_at = new Date();
+        chat.last_message_preview = messageText.substring(0, 100);
+        chat.message_count += 1;
+        await chat.save();
+        session.message_count += 1;
+        await session.save();
+        // Skip AI if session is human-taken-over or no agent
+        if (session.taken_over_by || !agentId) {
+            logger_1.default.info('Skipping AI response', {
+                sessionId,
+                hasTakeover: !!session.taken_over_by,
+                hasAgent: !!agentId,
+            });
+            return;
+        }
+        // Skip AI if any human has ever messaged in this chat
+        if (await this.hasHumanMessageInChat(chat._id)) {
+            logger_1.default.info('Skipping AI — human has previously messaged in this chat', {
+                sessionId,
+                chatId: chat._id.toString(),
+            });
+            return;
+        }
+        // Skip AI if outside shift hours
+        const tenant = await tenant_model_1.default.findById(tenantId).lean();
+        if (tenant && !this.isWithinAiShift(tenant)) {
+            logger_1.default.info('Skipping AI — outside AI shift hours', { sessionId });
+            return;
+        }
+        // Debounce: reset the message buffer timer so the AI waits for the
+        // contact to finish typing before responding to all messages at once.
+        this.cancelMessageBuffer(sessionId);
+        const bufferMs = Math.floor(Math.random() * (MESSAGE_BUFFER_MAX_MS - MESSAGE_BUFFER_MIN_MS + 1)) + MESSAGE_BUFFER_MIN_MS;
+        const bufferTimer = setTimeout(() => {
+            this.onMessageBufferExpired(sessionId, tenantId, agentId).catch(err => {
+                logger_1.default.error('Message buffer handler failed', {
+                    error: err.message,
+                    sessionId,
+                });
+            });
+        }, bufferMs);
+        this.messageBufferTimers.set(sessionId, bufferTimer);
+        logger_1.default.info('Message buffered, AI will respond after pause', {
+            sessionId,
+            bufferMs,
+            text: messageText.substring(0, 50),
+        });
+    }
+    // ─── ElevenLabs Connection ────────────────────────────────
+    async buildUserSummary(contactProfileId) {
+        if (!contactProfileId)
+            return { summary: '', hasMeaningfulContext: false };
+        const profile = await whatsapp_contact_profile_model_1.default.findById(contactProfileId).lean();
+        if (!profile)
+            return { summary: '', hasMeaningfulContext: false };
+        // Meaningful context = data beyond just a name (ai_summary, notes, tags, preferred_language)
+        const hasMeaningfulContext = !!(profile.ai_summary || profile.notes || (profile.tags && profile.tags.length > 0) || profile.preferred_language);
+        // No meaningful context → return empty so the fallback default is used
+        if (!hasMeaningfulContext)
+            return { summary: '', hasMeaningfulContext: false };
+        const parts = [];
+        if (profile.display_name && profile.display_name !== 'Bilinmiyor') {
+            parts.push(`Ad: ${profile.display_name}`);
+        }
+        if (profile.preferred_language) {
+            parts.push(`Tercih edilen dil: ${profile.preferred_language}`);
+        }
+        if (profile.notes) {
+            parts.push(`Notlar: ${profile.notes.substring(0, 500)}`);
+        }
+        if (profile.ai_summary) {
+            parts.push(`Gecmis ozeti: ${profile.ai_summary}`);
+        }
+        if (profile.tags.length > 0) {
+            parts.push(`Etiketler: ${profile.tags.join(', ')}`);
+        }
+        return { summary: parts.join('\n'), hasMeaningfulContext };
+    }
+    async createConnection(agentId, chat, session, options) {
+        const sessionId = session._id.toString();
+        let isReconnect = options?.isReconnect || false;
+        logger_1.default.info('Creating new EL conversation', { agentId, sessionId, isReconnect });
+        // Build user summary from contact profile BEFORE connecting
+        const { summary: profileSummary } = await this.buildUserSummary(chat.contact_profile_id?.toString() || null);
+        const userSummary = profileSummary || 'Ilk defa iletisime gecen hasta. Hakkinda bilgi bulunmamaktadir.';
+        // On reconnection + tenant has chat_continuity_enabled, build continuation directive
+        let continuationDirective = '';
+        if (isReconnect) {
+            const tenant = await tenant_model_1.default.findById(session.tenant_id).lean();
+            if (!tenant?.enabled_features?.includes('chat_continuity')) {
+                logger_1.default.info('Prompt continuation disabled for tenant, skipping directive', { sessionId });
+                isReconnect = false;
+            }
+        }
+        if (isReconnect) {
+            const chatHistory = await this.buildChatContext(chat._id.toString(), sessionId);
+            const lastAiMsg = await whatsapp_message_model_1.default.findOne({
+                session_id: session._id,
+                sender: 'human',
+                sender_name: 'AI',
+            }).sort({ createdAt: -1 }).lean();
+            const parts = [
+                'ÖNEMLİ — KONUŞMA DEVAMI:',
+                'Bu hasta ile önceden başlamış bir konuşma var. Teknik bir bağlantı yenilenmesi yaşandı.',
+                'Kendini TANITMA. Selam VERME. Hoşgeldin DEME. Konuşmaya kaldığın yerden DEVAM ET.',
+                lastAiMsg ? `En son gönderdiğin mesaj: "${lastAiMsg.text.substring(0, 300)}"` : '',
+                '',
+                chatHistory || '',
+            ].filter(Boolean).join('\n');
+            continuationDirective = parts;
+            logger_1.default.info('Built continuation directive for reconnection', {
+                sessionId,
+                directiveLength: continuationDirective.length,
+            });
+        }
+        const result = await elevenlabs_service_1.default.getSignedUrl({ agentId });
+        const signedUrl = result.signedUrl
+            || result.signed_url
+            || String(result);
+        const separator = signedUrl.includes('?') ? '&' : '?';
+        const wsUrl = `${signedUrl}${separator}textOnly=true`;
+        const ws = new ws_1.default(wsUrl);
+        const unipileChatId = chat.unipile_chat_id;
+        const conn = {
+            ws,
+            chatId: chat._id.toString(),
+            sessionId,
+            unipileChatId,
+            agentId,
+            lastActivity: Date.now(),
+            conversationId: null,
+            ready: false,
+            intentionallyClosed: false,
+            pingTimer: null,
+        };
+        // Wait for WS to open AND receive conversation_initiation_metadata
+        await new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                ws.close();
+                reject(new Error('ElevenLabs WS initialization timeout (15s)'));
+            }, 15_000);
+            ws.on('open', () => {
+                logger_1.default.info('ElevenLabs WS TCP connected, sending init data...', { unipileChatId, sessionId });
+                ws.send(JSON.stringify({
+                    type: 'conversation_initiation_client_data',
+                    conversation_config_override: {
+                        agent: { first_message: '' },
+                    },
+                    dynamic_variables: {
+                        user_summary: userSummary,
+                        current_date: new Date().toISOString().split('T')[0],
+                        continuation_directive: continuationDirective,
+                    },
+                }));
+                logger_1.default.info('Sent conversation_initiation_client_data', {
+                    sessionId,
+                    userSummaryLength: userSummary.length,
+                    isReconnect,
+                    continuationDirectiveLength: continuationDirective.length,
+                });
+            });
+            ws.on('error', (err) => {
+                clearTimeout(timeout);
+                reject(err);
+            });
+            ws.on('message', (data) => {
+                try {
+                    const msg = JSON.parse(data.toString());
+                    if (msg.type === 'conversation_initiation_metadata') {
+                        const convId = msg.conversation_initiation_metadata_event?.conversation_id
+                            || msg.conversation_id;
+                        if (convId) {
+                            conn.conversationId = convId;
+                            const updateOp = {
+                                $set: {
+                                    elevenlabs_conversation_id: convId,
+                                    elevenlabs_conversation_created_at: new Date(),
+                                    elevenlabs_last_interaction_at: new Date(),
+                                },
+                            };
+                            // Preserve previous conversation ID if this is a reconnection
+                            if (session.elevenlabs_conversation_id && session.elevenlabs_conversation_id !== convId) {
+                                updateOp.$push = { elevenlabs_previous_conversation_ids: session.elevenlabs_conversation_id };
+                            }
+                            whatsapp_session_model_1.default.updateOne({ _id: session._id }, updateOp).catch(() => { });
+                        }
+                        conn.ready = true;
+                        clearTimeout(timeout);
+                        logger_1.default.info('ElevenLabs conversation ready', {
+                            sessionId,
+                            conversationId: convId,
+                        });
+                        resolve();
+                    }
+                }
+                catch (err) {
+                    logger_1.default.error('Error parsing EL WS init message', { error: err.message });
+                }
+            });
+        });
+        // Start keepalive: TCP ping + EL user_activity to reset inactivity timer
+        conn.pingTimer = setInterval(() => {
+            if (conn.ws.readyState === ws_1.default.OPEN) {
+                conn.ws.ping();
+                conn.ws.send(JSON.stringify({ type: 'user_activity' }));
+            }
+        }, WS_PING_INTERVAL_MS);
+        // Persistent message handler for agent responses
+        ws.on('message', async (data) => {
+            try {
+                const msg = JSON.parse(data.toString());
+                if (msg.type === 'conversation_initiation_metadata')
+                    return;
+                // Respond to EL ping with pong
+                if (msg.type === 'ping') {
+                    const eventId = msg.ping_event?.event_id;
+                    if (eventId != null) {
+                        conn.ws.send(JSON.stringify({ type: 'pong', event_id: eventId }));
+                    }
+                    return;
+                }
+                logger_1.default.info('EL WS event', { type: msg.type, sessionId, raw: JSON.stringify(msg).substring(0, 400) });
+                if (msg.type === 'client_tool_call') {
+                    const { tool_call_id, tool_name, parameters } = msg.client_tool_call;
+                    this.handleClientToolCall(conn, tool_call_id, tool_name, parameters)
+                        .catch(err => logger_1.default.error('Client tool call failed', {
+                        tool_name,
+                        sessionId,
+                        error: err.message,
+                    }));
+                    return;
+                }
+                if (msg.type === 'agent_response') {
+                    const responseText = msg.agent_response_event?.agent_response
+                        || msg.agent_response;
+                    if (responseText) {
+                        await whatsapp_session_model_1.default.updateOne({ _id: session._id }, { elevenlabs_last_interaction_at: new Date() });
+                        await this.sendResponse(chat, session, responseText);
+                    }
+                }
+            }
+            catch (err) {
+                logger_1.default.error('Error handling EL WS message', {
+                    error: err.message,
+                    sessionId,
+                });
+            }
+        });
+        ws.on('close', (code, reason) => {
+            if (conn.pingTimer) {
+                clearInterval(conn.pingTimer);
+                conn.pingTimer = null;
+            }
+            logger_1.default.info('ElevenLabs WS closed', { unipileChatId, sessionId, code, reason: reason?.toString() });
+            this.connections.delete(unipileChatId);
+            // No eager reconnect — triggerAiResponse handles lazy reconnect on next message
+        });
+        ws.on('error', (err) => {
+            logger_1.default.error('ElevenLabs WS error', { error: err.message, sessionId });
+        });
+        return conn;
+    }
+    async sendResponse(chat, session, text) {
+        try {
+            const tenant = await tenant_model_1.default.findById(chat.tenant_id).lean();
+            const provider = unipile_service_1.default.getProviderForTenant(tenant);
+            const result = await unipile_service_1.default.sendMessage(provider, chat.unipile_chat_id, text);
+            logger_1.default.info('AI response sent via bridge', { provider, sessionId: session._id, text: text.substring(0, 50) });
+            await whatsapp_message_model_1.default.create({
+                chat_id: chat._id,
+                session_id: session._id,
+                tenant_id: chat.tenant_id,
+                unipile_message_id: result.message_id || null,
+                sender: 'human',
+                sender_name: 'AI',
+                text,
+                sent_via_unipile: true,
+            });
+            await whatsapp_chat_model_1.default.updateOne({ _id: chat._id }, {
+                $inc: { message_count: 1 },
+                $set: { last_message_at: new Date(), last_message_preview: text.substring(0, 100) },
+            });
+            await whatsapp_session_model_1.default.updateOne({ _id: session._id }, { $inc: { message_count: 1 } });
+        }
+        catch (err) {
+            logger_1.default.error('Failed to send AI response via bridge', {
+                sessionId: session._id,
+                error: err.message,
+            });
+        }
+    }
+    // ─── Contact Profile Update ──────────────────────────────
+    /**
+     * After a session resolves, update the contact profile's ai_summary
+     * by sending the session transcript + previous summary to a dedicated
+     * ElevenLabs agent via simulateConversation REST API.
+     * Fire-and-forget — errors are logged but never block session resolution.
+     */
+    async updateContactProfileSummary(sessionId) {
+        const session = await whatsapp_session_model_1.default.findById(sessionId).lean();
+        if (!session || session.message_count < 2) {
+            throw new Error('Session not found or has fewer than 2 messages');
+        }
+        const chat = await whatsapp_chat_model_1.default.findById(session.chat_id).lean();
+        if (!chat?.contact_profile_id) {
+            throw new Error('Chat has no linked contact profile');
+        }
+        const profile = await whatsapp_contact_profile_model_1.default.findById(chat.contact_profile_id).lean();
+        if (!profile) {
+            throw new Error('Contact profile not found');
+        }
+        // Build the transcript from session messages
+        const messages = await whatsapp_message_model_1.default.find({ session_id: session._id })
+            .sort({ createdAt: 1 })
+            .lean();
+        if (messages.length < 2) {
+            throw new Error('Session has fewer than 2 messages');
+        }
+        const transcript = messages
+            .map(m => {
+            const role = m.sender === 'contact' ? 'HASTA' : 'ASISTAN';
+            const ts = new Date(m.createdAt).toLocaleString('tr-TR', { timeZone: 'Europe/Istanbul' });
+            return `[${ts}] [${role}]: ${m.text}`;
+        })
+            .join('\n');
+        const now = new Date().toLocaleString('tr-TR', { timeZone: 'Europe/Istanbul' });
+        const previousSummary = profile.ai_summary || 'Henüz profil özeti yok.';
+        const systemMessage = [
+            'Sen bir hasta profil özeti oluşturma asistanısın.',
+            'Sana mevcut hasta profil özeti ve bir WhatsApp konuşma geçmişi verilecek.',
+            '',
+            'KURALLAR:',
+            '- [HASTA] etiketli satırlar hastanın yazdıklarıdır — SADECE buradan bilgi çıkar.',
+            '- [ASISTAN] etiketli satırlar bizim AI asistanımızın/operatörümüzün yazdıklarıdır — bunları hasta bilgisi olarak KULLANMA.',
+            '- "Yarın", "bugün", "haftaya" gibi göreceli tarihleri mesajın gönderildiği tarihe göre gerçek tarihe çevir (ör: 19.02.2026 tarihli mesajda "yarın" = 20.02.2026).',
+            '- Yanıtın SADECE güncellenmiş profil özeti olmalı. Başka açıklama, selamlama veya soru ekleme.',
+            '- Türkçe yaz.',
+            '- Özeti madde işaretleri ile yapılandır.',
+            '- Şu kategorileri kullan (bilgi varsa):',
+            '  • Kişisel Bilgiler (ad, yaş, cinsiyet, meslek, konum vb.)',
+            '  • Sağlık Durumu (şikayetler, tanılar, tedaviler, ilaçlar)',
+            '  • Randevu Geçmişi (önceki/planlanan randevular, gerçek tarihler ile)',
+            '  • İletişim Tercihleri (iletişim tarzı, hassasiyetler)',
+            '  • Tercih Edilen Dil (hastanın mesajlarında kullandığı dil — ör: Türkçe, English, العربية, Русский)',
+            '  • Önemli Notlar (özel durumlar, talepler, dikkat edilecekler)',
+            '- Önceki özette olan ama yeni konuşmada güncellenmeyen bilgileri koru.',
+            '- Yeni konuşmadan çıkan bilgilerle çelişen eski bilgileri güncelle.',
+            '- Spekülasyon yapma, sadece hastanın kendi söylediklerinden çıkarılabilecek bilgileri yaz.',
+            '- Özet 500 kelimeyi geçmesin.',
+            '- Özetin EN SON satırında, hastanın mesajlarında kullandığı dili şu formatta yaz: PREFERRED_LANGUAGE: <dil>',
+            '  Örnek: PREFERRED_LANGUAGE: English',
+            '  Eğer hasta Türkçe yazıyorsa: PREFERRED_LANGUAGE: Türkçe',
+            '  Bu satır her zaman olmalı.',
+        ].join('\n');
+        const userMessage = [
+            `Bugünün tarihi: ${now}`,
+            '',
+            `--- Mevcut hasta profili ---`,
+            previousSummary,
+            '',
+            `--- Konuşma geçmişi ---`,
+            transcript,
+        ].join('\n');
+        const aiService = (0, ai_1.createAIService)();
+        const result = await aiService.generateSummary([], {
+            systemMessage,
+            summaryPrompt: userMessage,
+            language: 'tr',
+            maxTokens: 1000,
+        });
+        const rawSummary = result.summary?.trim();
+        if (!rawSummary) {
+            throw new Error('AI did not return a summary response');
+        }
+        // Extract PREFERRED_LANGUAGE line and remove it from the summary text
+        const langMatch = rawSummary.match(/PREFERRED_LANGUAGE:\s*(.+)/i);
+        const preferredLanguage = langMatch ? langMatch[1].trim() : '';
+        const summaryText = rawSummary.replace(/\n?PREFERRED_LANGUAGE:\s*.+/i, '').trim();
+        const updateFields = { ai_summary: summaryText };
+        if (preferredLanguage) {
+            updateFields.preferred_language = preferredLanguage;
+        }
+        await whatsapp_contact_profile_model_1.default.updateOne({ _id: profile._id }, { $set: updateFields });
+        logger_1.default.info('Contact profile summary updated', {
+            sessionId,
+            profileId: profile._id,
+            summaryLength: summaryText.length,
+            model: result.model,
+        });
+    }
+    /**
+     * Generate session labels (sentiment, categories, summary) and create a Lead record.
+     * Called after session resolves. Fire-and-forget.
+     */
+    async generateSessionLabels(sessionId) {
+        logger_1.default.info('generateSessionLabels called', { sessionId });
+        const session = await whatsapp_session_model_1.default.findById(sessionId);
+        if (!session || session.message_count < 2) {
+            logger_1.default.info('generateSessionLabels skipped — not enough messages', { sessionId, message_count: session?.message_count });
+            return;
+        }
+        const messages = await whatsapp_message_model_1.default.find({ session_id: session._id })
+            .sort({ createdAt: 1 }).lean();
+        if (messages.length < 2) {
+            logger_1.default.info('generateSessionLabels skipped — fewer than 2 messages found', { sessionId, found: messages.length });
+            return;
+        }
+        const chat = await whatsapp_chat_model_1.default.findById(session.chat_id).lean();
+        const contactName = chat?.contact_name || 'Hasta';
+        const transcript = messages
+            .map(m => {
+            const role = m.sender === 'contact' ? contactName : 'ASISTAN';
+            return `[${role}]: ${m.text}`;
+        })
+            .join('\n');
+        const openai = new openai_1.default({ apiKey: config_1.default.ai.openai.apiKey });
+        const response = await openai.chat.completions.create({
+            model: 'gpt-5.4-mini',
+            messages: [
+                { role: 'system', content: 'Sen bir saglik kliniginin WhatsApp konusmalarini analiz eden uzman bir asistansin. Yanitini YALNIZCA gecerli JSON olarak ver.' },
+                { role: 'user', content: `Asagidaki WhatsApp konusmasini dikkatle oku. ODAK NOKTASI: Hastanin (kullanicinin) talep ve niyetini anla. Asistanin/AI'in verdigi cevaplari degil, HASTANIN ne istedigini, ne sordugunu, ne talep ettigini analiz et.
+
+KURALLAR:
+- Yanitini YALNIZCA gecerli JSON olarak ver. Baska hicbir sey yazma (markdown, backtick, aciklama yok).
+- Tum metin alanlari Turkce olmali.
+- null yerine bos string kullanma — bilinmeyen degerler icin null yaz.
+- Kategoriyi HASTANIN TALEBINE gore sec, asistanin cevabina gore degil.
+
+JSON SEMASI:
+{
+  "ozet": "Hastanin talebi ve gorusme sonucu (2-3 cumle): hasta ne istedi/sordu, ne oldu",
+  "sentiment": "positive | neutral | negative",
+  "categories": ["asagidaki listeden en uygun TEK kategoriyi sec"],
+  "lead": {
+    "name": "Hastanin ismi (mesajda veya rehber ismi: ${contactName} — eger '${contactName}' gercek bir isim degilse veya sadece numara ise null yaz)",
+    "service_of_interest": "Hastanin sordugu/ilgilendigi spesifik hizmet veya tedavi (burun estetigi, dis beyazlatma, sac ekimi vb. — genel soruylaysa null)",
+    "summary": "Hastanin talebi ve gorusme sonucu: hasta ne istedi/sordu, sonuc ne oldu (1-2 cumle)"
+  }
+}
+
+KATEGORI TANIMLARI — hastanin asil talebine gore sec:
+- appointment_inquiry: Hasta randevu almak, degistirmek veya iptal etmek istiyor; muayene/tedavi icin gun/saat soruyor; "ne zaman gelebilirim" tarzi sorular
+- callback_required: Hasta bir konuda geri donus bekliyor; asistan "sizi ararız/bilgi veririz" demis; hasta "doktor beni arasin" veya "telefonla konusmak istiyorum" demis; henuz sonuclanan bir islem yok
+- other: Hastanin talebi yukaridaki kategorilere uymuyor — fiyat sorusu, genel bilgi, adres/ulasim, tesekkur, selamlasma vb.
+
+SENTIMENT — hastanin tavrini ve gorusmenin sonucunu birlikte degerlendir:
+- positive: Hasta memnun ayrildi, istedigini aldi, randevu kesinlesti, sorulari cevaplandi
+- neutral: Standart bilgi alis-verisi, hasta ne memnun ne memnuniyetsiz
+- negative: Hasta sikayetci, kizgin, istedigini alamadi, gorusme olumsuz sonuclandi
+
+Konusma:
+${transcript}` },
+            ],
+            max_completion_tokens: 500,
+            temperature: 0.3,
+        });
+        const content = response.choices[0].message.content || '';
+        const update = {};
+        try {
+            const parsed = JSON.parse(content);
+            update.llm_summary = parsed.ozet || content;
+            if (['positive', 'neutral', 'negative'].includes(parsed.sentiment)) {
+                update.sentiment = parsed.sentiment;
+            }
+            const cats = Array.isArray(parsed.categories) && parsed.categories.length > 0 ? parsed.categories : ['other'];
+            update.categories = cats;
+            // Create Lead record
+            if (parsed.lead && chat) {
+                try {
+                    await lead_model_1.default.create({
+                        tenant_id: session.tenant_id,
+                        source_type: 'whatsapp',
+                        source_id: session._id,
+                        chat_id: chat._id,
+                        name: parsed.lead.name || null,
+                        phone: chat.contact_phone || '',
+                        service_of_interest: parsed.lead.service_of_interest || null,
+                        channel: 'whatsapp',
+                        categories: cats,
+                        summary: parsed.lead.summary || null,
+                    });
+                    logger_1.default.info('Lead created from WhatsApp session', { sessionId, phone: chat.contact_phone });
+                }
+                catch (err) {
+                    const code = err.code;
+                    if (code === 11000) {
+                        logger_1.default.info('Lead already exists for session', { sessionId });
+                    }
+                    else {
+                        throw err;
+                    }
+                }
+            }
+        }
+        catch {
+            update.llm_summary = content || null;
+        }
+        await whatsapp_session_model_1.default.updateOne({ _id: session._id }, { $set: update });
+        logger_1.default.info('Session labels generated', {
+            sessionId,
+            sentiment: update.sentiment,
+            categories: update.categories,
+        });
+    }
+    // ─── Connection Management ────────────────────────────────
+    closeConnection(unipileChatId) {
+        const conn = this.connections.get(unipileChatId);
+        if (conn) {
+            if (conn.pingTimer) {
+                clearInterval(conn.pingTimer);
+                conn.pingTimer = null;
+            }
+            conn.intentionallyClosed = true;
+            conn.ws.close();
+            this.connections.delete(unipileChatId);
+            this.cancelMessageBuffer(conn.sessionId);
+            logger_1.default.info('Closed EL connection for chat', { unipileChatId });
+        }
+    }
+    // ─── Client Tool Call Handling ───────────────────────────
+    async handleClientToolCall(conn, toolCallId, toolName, parameters) {
+        let result;
+        let isError = false;
+        try {
+            switch (toolName) {
+                case 'forward_to_operator':
+                    result = await this.toolForwardToOperator(conn, parameters);
+                    break;
+                case 'forward_conversation_to_operator':
+                    result = await this.toolForwardConversationToOperator(conn, parameters);
+                    break;
+                case 'send_example_photo':
+                    result = await this.toolSendExamplePhoto(conn);
+                    break;
+                case 'call_patient':
+                    result = await this.toolCallPatient(conn, parameters);
+                    break;
+                case 'check_availability':
+                    result = await this.toolCheckAvailability(conn, parameters);
+                    break;
+                case 'reserve_slot':
+                    result = await this.toolReserveSlot(conn, parameters);
+                    break;
+                case 'list_reservations':
+                    result = await this.toolListReservations(conn, parameters);
+                    break;
+                case 'cancel_reservation':
+                    result = await this.toolCancelReservation(conn, parameters);
+                    break;
+                case 'check_patient_history':
+                    result = await this.toolCheckPatientHistory(conn, parameters);
+                    break;
+                case 'reschedule_reservation':
+                    result = await this.toolRescheduleReservation(conn, parameters);
+                    break;
+                default:
+                    result = JSON.stringify({ error: `Unknown tool: ${toolName}` });
+                    isError = true;
+            }
+        }
+        catch (err) {
+            result = JSON.stringify({ error: err.message });
+            isError = true;
+        }
+        conn.ws.send(JSON.stringify({
+            type: 'client_tool_result',
+            tool_call_id: toolCallId,
+            result,
+            is_error: isError,
+        }));
+        logger_1.default.info('Client tool call completed', {
+            toolName,
+            toolCallId,
+            sessionId: conn.sessionId,
+            resultPreview: result.substring(0, 200),
+        });
+    }
+    async toolSendExamplePhoto(conn) {
+        const session = await whatsapp_session_model_1.default.findById(conn.sessionId);
+        if (!session)
+            return JSON.stringify({ error: 'Session not found' });
+        const chat = await whatsapp_chat_model_1.default.findById(conn.chatId);
+        if (!chat)
+            return JSON.stringify({ error: 'Chat not found' });
+        const tenant = await tenant_model_1.default.findById(session.tenant_id);
+        if (!tenant)
+            return JSON.stringify({ error: 'Tenant not found' });
+        const opSettings = tenant.settings?.whatsapp_agent;
+        if (!opSettings?.operator_example_photo_enabled || !opSettings.operator_example_photo_base64) {
+            return JSON.stringify({ error: 'Rehber fotoğraf yapılandırılmamış' });
+        }
+        const dataUrl = opSettings.operator_example_photo_base64;
+        // Strip "data:image/...;base64," prefix
+        const rawBase64 = dataUrl.replace(/^data:image\/[^;]+;base64,/, '');
+        const caption = opSettings.operator_example_photo_caption || '';
+        const provider = unipile_service_1.default.getProviderForTenant(tenant);
+        try {
+            await unipile_service_1.default.sendImage(provider, chat.unipile_chat_id, rawBase64, caption);
+            // Pre-create message record so the Baileys echo webhook dedup catches it
+            // and doesn't store it as an incoming 'contact' message
+            await whatsapp_message_model_1.default.create({
+                chat_id: chat._id,
+                session_id: session._id,
+                tenant_id: session.tenant_id,
+                unipile_message_id: null,
+                sender: 'ai',
+                sender_name: 'AI',
+                text: caption || '[Rehber fotoğraf]',
+                media_type: 'imageMessage',
+                sent_via_unipile: true,
+            });
+        }
+        catch (err) {
+            logger_1.default.error('Failed to send example photo', { error: err.message });
+            return JSON.stringify({ sent: false, error: err.message });
+        }
+        logger_1.default.info('Sent example photo to patient', { sessionId: conn.sessionId, chatId: conn.chatId });
+        return JSON.stringify({ sent: true });
+    }
+    async toolForwardToOperator(conn, parameters) {
+        const session = await whatsapp_session_model_1.default.findById(conn.sessionId);
+        if (!session || session.status === 'resolved') {
+            return JSON.stringify({ error: 'Session not found or already resolved' });
+        }
+        const chat = await whatsapp_chat_model_1.default.findById(conn.chatId);
+        if (!chat) {
+            return JSON.stringify({ error: 'Chat not found' });
+        }
+        const tenant = await tenant_model_1.default.findById(session.tenant_id);
+        if (!tenant) {
+            return JSON.stringify({ error: 'Tenant not found' });
+        }
+        const opSettings = tenant.settings?.whatsapp_agent;
+        if (!opSettings?.operator_workflow_enabled || !opSettings.operator_phone) {
+            return JSON.stringify({ error: 'Operator workflow not configured' });
+        }
+        const operatorPhone = opSettings.operator_phone;
+        const prefix = opSettings.operator_ref_prefix || 'R';
+        const timeoutHours = opSettings.operator_request_timeout_hours || 24;
+        // Find ALL media messages from the patient in this session (oldest first)
+        // Only include image/video/document types (skip stickers, contacts, locations etc.)
+        const FORWARDABLE_TYPES = ['imageMessage', 'videoMessage', 'documentMessage'];
+        const allMedia = await whatsapp_message_model_1.default.find({
+            session_id: session._id,
+            sender: 'contact',
+            media_type: { $in: FORWARDABLE_TYPES },
+        }).sort({ createdAt: 1 }).lean();
+        logger_1.default.info('Media messages found for forwarding', {
+            sessionId: session._id,
+            count: allMedia.length,
+            types: allMedia.map(m => m.media_type),
+            ids: allMedia.map(m => m.unipile_message_id),
+        });
+        // Use session-level REF code (generated at session creation)
+        const refCode = session.ref_code || await this.generateRefCode(tenant._id.toString(), prefix);
+        // Create OperatorRequest with array fields
+        await operator_request_model_1.default.create({
+            tenant_id: tenant._id,
+            session_id: session._id,
+            chat_id: chat._id,
+            ref_code: refCode,
+            request_type: 'operator_review',
+            status: 'pending',
+            forwarded_media_types: allMedia.map(m => m.media_type || 'unknown'),
+            forwarded_at: new Date(),
+            forwarded_to_phone: operatorPhone,
+            patient_message_ids: allMedia.map(m => m._id),
+            forwarded_count: allMedia.length,
+            failed_count: 0,
+            expires_at: new Date(Date.now() + timeoutHours * 60 * 60 * 1000),
+        });
+        // Mark session as awaiting operator
+        session.awaiting_operator = true;
+        await session.save();
+        const note = parameters.message || '';
+        const provider = unipile_service_1.default.getProviderForTenant(tenant);
+        const total = allMedia.length;
+        let forwardedOk = 0;
+        let failedCount = 0;
+        try {
+            if (total > 0) {
+                for (let i = 0; i < total; i++) {
+                    const media = allMedia[i];
+                    const caption = i === 0
+                        ? `REF: ${refCode}\nHasta: ${chat.contact_phone}\nHasta adı: ${chat.contact_name}${total > 1 ? `\nFotoğraf: 1/${total}` : ''}${note ? '\nNot: ' + note : ''}`
+                        : `REF: ${refCode} (${i + 1}/${total})`;
+                    try {
+                        await unipile_service_1.default.forwardMedia(provider, chat.unipile_chat_id, media.unipile_message_id, operatorPhone, caption);
+                        forwardedOk++;
+                    }
+                    catch (err) {
+                        failedCount++;
+                        logger_1.default.warn('Failed to forward media to operator', {
+                            refCode, index: i + 1, total,
+                            messageId: media.unipile_message_id,
+                            error: err.message,
+                        });
+                    }
+                    // Small delay between sends to avoid WA rate limiting
+                    if (i < total - 1) {
+                        await new Promise(resolve => setTimeout(resolve, 500));
+                    }
+                }
+            }
+            else {
+                // No media — just send text to operator
+                const accountId = tenant.settings.whatsapp_agent.unipile_account_id;
+                if (accountId) {
+                    const operatorJid = operatorPhone.replace(/[^0-9]/g, '') + '@s.whatsapp.net';
+                    const operatorChatId = `${accountId}:${operatorJid}`;
+                    const caption = `REF: ${refCode}\nHasta: ${chat.contact_phone}\nHasta adı: ${chat.contact_name}${note ? '\nNot: ' + note : ''}`;
+                    await unipile_service_1.default.sendMessage(provider, operatorChatId, caption);
+                }
+            }
+        }
+        catch (err) {
+            logger_1.default.error('Failed to forward to operator', { refCode, error: err.message });
+            return JSON.stringify({ ref_code: refCode, forwarded: false, error: err.message });
+        }
+        // Update failed count on the request
+        if (failedCount > 0) {
+            await operator_request_model_1.default.updateOne({ ref_code: refCode, tenant_id: tenant._id }, { $set: { failed_count: failedCount } });
+        }
+        logger_1.default.info('Forwarded to operator via tool call', {
+            refCode, sessionId: conn.sessionId, total_media: total,
+            forwarded_ok: forwardedOk, failed: failedCount,
+        });
+        return JSON.stringify({
+            ref_code: refCode,
+            forwarded: true,
+            total_media: total,
+            forwarded_ok: forwardedOk,
+            failed: failedCount,
+            ...(failedCount > 0 ? { failed_reason: `${failedCount} medya iletilemedi (önbellek süresi dolmuş olabilir)` } : {}),
+        });
+    }
+    async toolForwardConversationToOperator(conn, parameters) {
+        const session = await whatsapp_session_model_1.default.findById(conn.sessionId);
+        if (!session || session.status === 'resolved') {
+            return JSON.stringify({ error: 'Session not found or already resolved' });
+        }
+        const chat = await whatsapp_chat_model_1.default.findById(conn.chatId);
+        if (!chat)
+            return JSON.stringify({ error: 'Chat not found' });
+        const tenant = await tenant_model_1.default.findById(session.tenant_id);
+        if (!tenant)
+            return JSON.stringify({ error: 'Tenant not found' });
+        if (!tenant.enabled_features.includes('conversation_forwarding')) {
+            return JSON.stringify({ error: 'Conversation forwarding not enabled' });
+        }
+        const forwardPhone = tenant.settings?.whatsapp_agent?.conversation_forwarding_phone;
+        if (!forwardPhone) {
+            return JSON.stringify({ error: 'Conversation forwarding phone not configured' });
+        }
+        const summary = parameters.summary || '';
+        const rawMessages = parameters.patient_messages;
+        const patientMessages = Array.isArray(rawMessages)
+            ? rawMessages
+            : (typeof rawMessages === 'string' && rawMessages ? [rawMessages] : []);
+        if (!summary && patientMessages.length === 0) {
+            return JSON.stringify({ error: 'summary or patient_messages required' });
+        }
+        const refCode = session.ref_code || await this.generateRefCode(tenant._id.toString(), tenant.settings?.whatsapp_agent?.operator_ref_prefix || 'R');
+        const timeoutHours = tenant.settings?.whatsapp_agent?.operator_request_timeout_hours || 24;
+        await operator_request_model_1.default.create({
+            tenant_id: tenant._id,
+            session_id: session._id,
+            chat_id: chat._id,
+            ref_code: refCode,
+            request_type: 'conversation_review',
+            status: 'pending',
+            forwarded_at: new Date(),
+            forwarded_to_phone: forwardPhone,
+            forwarded_count: patientMessages.length,
+            expires_at: new Date(Date.now() + timeoutHours * 60 * 60 * 1000),
+        });
+        session.awaiting_operator = true;
+        if (!session.ref_code)
+            session.ref_code = refCode;
+        await session.save();
+        // Build message for the doctor
+        const lines = [`REF: ${refCode}`, `Hasta: ${chat.contact_phone}`, `Hasta adı: ${chat.contact_name}`];
+        if (summary)
+            lines.push('', `Özet: ${summary}`);
+        if (patientMessages.length > 0) {
+            lines.push('', 'Hasta mesajları:');
+            for (const msg of patientMessages) {
+                lines.push(`- ${msg}`);
+            }
+        }
+        const messageText = lines.join('\n');
+        const provider = unipile_service_1.default.getProviderForTenant(tenant);
+        const accountId = tenant.settings.whatsapp_agent.unipile_account_id;
+        try {
+            if (accountId) {
+                const forwardJid = forwardPhone.replace(/[^0-9]/g, '') + '@s.whatsapp.net';
+                const forwardChatId = `${accountId}:${forwardJid}`;
+                await unipile_service_1.default.sendMessage(provider, forwardChatId, messageText);
+            }
+        }
+        catch (err) {
+            logger_1.default.error('Failed to forward conversation to operator', { refCode, error: err.message });
+            return JSON.stringify({ ref_code: refCode, forwarded: false, error: err.message });
+        }
+        logger_1.default.info('Forwarded conversation to operator', {
+            refCode, sessionId: conn.sessionId, messageCount: patientMessages.length,
+        });
+        return JSON.stringify({
+            ref_code: refCode,
+            forwarded: true,
+            message_count: patientMessages.length,
+        });
+    }
+    async generateRefCode(tenantId, prefix) {
+        const chars = 'ABCDEFGHJKLMNPQRSTUVWXYZ23456789';
+        for (let attempt = 0; attempt < 5; attempt++) {
+            const rand = Array.from({ length: 4 }, () => chars[Math.floor(Math.random() * chars.length)]).join('');
+            const code = `${prefix}-${rand}`;
+            const [inRequest, inSession] = await Promise.all([
+                operator_request_model_1.default.exists({ ref_code: code, tenant_id: tenantId }),
+                whatsapp_session_model_1.default.exists({ ref_code: code, tenant_id: tenantId }),
+            ]);
+            if (!inRequest && !inSession)
+                return code;
+        }
+        return `${prefix}-${Date.now().toString(36).slice(-4).toUpperCase()}`;
+    }
+    // ─── Outbound Call Tool ──────────────────────────────────
+    async toolCallPatient(conn, parameters) {
+        const session = await whatsapp_session_model_1.default.findById(conn.sessionId);
+        if (!session || session.status === 'resolved') {
+            return JSON.stringify({ error: 'Session not found or already resolved' });
+        }
+        const chat = await whatsapp_chat_model_1.default.findById(conn.chatId);
+        if (!chat) {
+            return JSON.stringify({ error: 'Chat not found' });
+        }
+        const tenant = await tenant_model_1.default.findById(session.tenant_id);
+        if (!tenant) {
+            return JSON.stringify({ error: 'Tenant not found' });
+        }
+        const callSettings = tenant.settings?.whatsapp_agent;
+        if (!callSettings?.outbound_call_enabled) {
+            return JSON.stringify({ error: 'Outbound calling not enabled' });
+        }
+        if (!callSettings.outbound_call_phone_number_id) {
+            return JSON.stringify({ error: 'Outbound call not fully configured (missing phone_number_id)' });
+        }
+        // Resolve the voice agent — use dedicated call agent or fall back to chat agent
+        let voiceAgentId = null;
+        if (callSettings.outbound_call_agent_id) {
+            const callAgent = await agent_model_1.default.findById(callSettings.outbound_call_agent_id).lean();
+            if (callAgent?.is_active) {
+                voiceAgentId = callAgent.elevenlabs_agent_id;
+            }
+        }
+        if (!voiceAgentId) {
+            voiceAgentId = conn.agentId;
+        }
+        if (!voiceAgentId) {
+            return JSON.stringify({ error: 'No agent available for voice call' });
+        }
+        // Format patient phone as E.164 for Twilio (e.g. +905551234567)
+        const rawPhone = chat.contact_phone.replace(/[^0-9+]/g, '');
+        const patientPhone = rawPhone.startsWith('+') ? rawPhone : `+${rawPhone}`;
+        if (patientPhone.length < 8) {
+            return JSON.stringify({ error: 'Patient phone number not available' });
+        }
+        // Build full conversation context (messages + operator events) for the voice agent
+        const reason = parameters.reason || '';
+        const chatContext = await this.buildChatContext(conn.chatId, conn.sessionId) || '';
+        try {
+            const result = await elevenlabs_service_1.default.sipTrunkOutboundCall({
+                agentId: voiceAgentId,
+                agentPhoneNumberId: callSettings.outbound_call_phone_number_id,
+                toNumber: patientPhone,
+                conversationInitiationClientData: {
+                    dynamicVariables: {
+                        patient_name: chat.contact_name || 'Hasta',
+                        patient_phone: patientPhone,
+                        conversation_history: chatContext,
+                        call_reason: reason,
+                    },
+                },
+            });
+            logger_1.default.info('Outbound call initiated via tool', {
+                sessionId: conn.sessionId,
+                patientPhone,
+                conversationId: result?.conversationId,
+                sipCallId: result?.sipCallId,
+                voiceAgentId,
+                message: result?.message,
+            });
+            // Parse SIP failure from message (e.g. "INVITE failed: sip status: 486: User Busy (SIP 486)")
+            const sipFailure = this.parseSipFailure(result?.message || '');
+            if (sipFailure) {
+                return JSON.stringify({
+                    success: false,
+                    reason: sipFailure,
+                    conversation_id: result?.conversationId || null,
+                });
+            }
+            return JSON.stringify({
+                success: true,
+                conversation_id: result?.conversationId || null,
+            });
+        }
+        catch (err) {
+            logger_1.default.error('Failed to initiate outbound call', {
+                sessionId: conn.sessionId,
+                patientPhone,
+                error: err.message,
+            });
+            return JSON.stringify({ error: 'Call failed: ' + err.message });
+        }
+    }
+    /**
+     * Parse SIP error from the outbound call response message.
+     * Returns a human-readable Turkish reason if it's a SIP failure, null if call succeeded.
+     */
+    parseSipFailure(message) {
+        if (!message)
+            return null;
+        const sipMatch = message.match(/sip\s*status:\s*(\d{3})/i);
+        if (!sipMatch)
+            return null;
+        const code = parseInt(sipMatch[1], 10);
+        // 2xx = success
+        if (code >= 200 && code < 300)
+            return null;
+        const reasons = {
+            486: 'Hasta meşgul, telefonu kullanıyor',
+            487: 'Arama iptal edildi',
+            480: 'Hasta şu an ulaşılamıyor',
+            408: 'Hasta yanıt vermedi, zaman aşımı',
+            603: 'Hasta aramayı reddetti',
+            404: 'Numara bulunamadı',
+            503: 'Telefon hizmeti geçici olarak kullanılamıyor',
+            504: 'Bağlantı zaman aşımına uğradı',
+        };
+        return reasons[code] || `Arama başarısız oldu (SIP ${code})`;
+    }
+    // ─── Google Calendar Tools ──────────────────────────────
+    async toolCheckAvailability(conn, parameters) {
+        const session = await whatsapp_session_model_1.default.findById(conn.sessionId);
+        if (!session)
+            return JSON.stringify({ error: 'Session not found' });
+        const tenant = await tenant_model_1.default.findById(session.tenant_id);
+        if (!tenant)
+            return JSON.stringify({ error: 'Tenant not found' });
+        const gcal = tenant.settings?.whatsapp_agent?.google_calendar;
+        if (!gcal?.connected || !gcal?.calendar_id) {
+            return JSON.stringify({ error: 'Google Calendar not configured' });
+        }
+        const date = parameters.date;
+        if (!date || !/^\d{4}-\d{2}-\d{2}$/.test(date)) {
+            return JSON.stringify({ error: 'Invalid date format. Use YYYY-MM-DD' });
+        }
+        const today = new Date().toISOString().split('T')[0];
+        if (date < today) {
+            return JSON.stringify({ error: `Geçmiş tarih için randevu oluşturulamaz. Bugünün tarihi: ${today}` });
+        }
+        const result = await google_calendar_service_1.default.checkAvailability(tenant._id.toString(), date);
+        if (result.slots.length === 0) {
+            return JSON.stringify({
+                date,
+                available_slots: [],
+                message: result.message || 'Bu tarihte müsait randevu yok',
+            });
+        }
+        return JSON.stringify({
+            date,
+            available_slots: result.slots,
+            appointment_duration_minutes: gcal.appointment_duration_minutes,
+        });
+    }
+    async toolReserveSlot(conn, parameters) {
+        const session = await whatsapp_session_model_1.default.findById(conn.sessionId);
+        if (!session)
+            return JSON.stringify({ error: 'Session not found' });
+        const tenant = await tenant_model_1.default.findById(session.tenant_id);
+        if (!tenant)
+            return JSON.stringify({ error: 'Tenant not found' });
+        const gcal = tenant.settings?.whatsapp_agent?.google_calendar;
+        if (!gcal?.connected || !gcal?.calendar_id) {
+            return JSON.stringify({ error: 'Google Calendar not configured' });
+        }
+        const chat = await whatsapp_chat_model_1.default.findById(conn.chatId);
+        const patientName = parameters.patient_name
+            || chat?.contact_name
+            || 'Bilinmeyen Hasta';
+        const patientPhone = chat?.contact_phone || '';
+        const isoStart = parameters.iso_start;
+        const isoEnd = parameters.iso_end;
+        const notes = parameters.notes || '';
+        if (!isoStart || !isoEnd) {
+            return JSON.stringify({ error: 'iso_start and iso_end are required' });
+        }
+        // Pre-generate appointment ID so we can include the detail link in the calendar event
+        const appointmentId = new mongoose_1.default.Types.ObjectId();
+        const result = await google_calendar_service_1.default.reserveSlot(tenant._id.toString(), { iso_start: isoStart, iso_end: isoEnd, patient_name: patientName, patient_phone: patientPhone, notes, appointment_id: appointmentId.toString() });
+        // Persist appointment locally for analytics
+        appointment_model_1.default.create({
+            _id: appointmentId,
+            tenant_id: session.tenant_id,
+            chat_id: session.chat_id,
+            session_id: session._id,
+            google_event_id: result.event_id,
+            patient_name: patientName,
+            patient_phone: patientPhone,
+            start_time: new Date(result.start),
+            end_time: new Date(result.end),
+            duration_minutes: gcal.appointment_duration_minutes,
+            notes,
+            status: 'scheduled',
+        }).catch(err => logger_1.default.error('Failed to persist appointment', { error: err.message }));
+        // SMS notification to doctor (fire-and-forget)
+        const smsSettings = tenant.settings?.whatsapp_agent;
+        if (smsSettings?.sms_notification_enabled && smsSettings.sms_notification_phones?.length) {
+            const startDt = new Date(result.start);
+            const tz = gcal.timezone || 'Europe/Istanbul';
+            netgsm_service_1.default.notifyAppointmentCreated({
+                phones: smsSettings.sms_notification_phones,
+                patientName,
+                patientPhone,
+                date: startDt.toLocaleDateString('tr-TR', { day: 'numeric', month: 'long', year: 'numeric', weekday: 'long', timeZone: tz }),
+                time: startDt.toLocaleTimeString('tr-TR', { hour: '2-digit', minute: '2-digit', timeZone: tz }),
+                notes,
+                detailUrl: `${config_1.default.google.frontendUrl}/appointments/${appointmentId}`,
+            }).catch(err => logger_1.default.error('SMS notification failed (create)', { error: err.message }));
+        }
+        return JSON.stringify({
+            reserved: true,
+            event_id: result.event_id,
+            start: result.start,
+            end: result.end,
+            patient_name: patientName,
+        });
+    }
+    async toolListReservations(conn, _parameters) {
+        const session = await whatsapp_session_model_1.default.findById(conn.sessionId);
+        if (!session)
+            return JSON.stringify({ error: 'Session not found' });
+        const tenant = await tenant_model_1.default.findById(session.tenant_id);
+        if (!tenant)
+            return JSON.stringify({ error: 'Tenant not found' });
+        const gcal = tenant.settings?.whatsapp_agent?.google_calendar;
+        if (!gcal?.connected || !gcal?.calendar_id) {
+            return JSON.stringify({ error: 'Google Calendar not configured' });
+        }
+        const chat = await whatsapp_chat_model_1.default.findById(conn.chatId);
+        const patientPhone = chat?.contact_phone || '';
+        if (!patientPhone) {
+            return JSON.stringify({ error: 'Patient phone not available' });
+        }
+        const reservations = await google_calendar_service_1.default.listReservations(tenant._id.toString(), patientPhone);
+        return JSON.stringify({
+            reservations,
+            count: reservations.length,
+        });
+    }
+    async toolCancelReservation(conn, parameters) {
+        const session = await whatsapp_session_model_1.default.findById(conn.sessionId);
+        if (!session)
+            return JSON.stringify({ error: 'Session not found' });
+        const tenant = await tenant_model_1.default.findById(session.tenant_id);
+        if (!tenant)
+            return JSON.stringify({ error: 'Tenant not found' });
+        const gcal = tenant.settings?.whatsapp_agent?.google_calendar;
+        if (!gcal?.connected || !gcal?.calendar_id) {
+            return JSON.stringify({ error: 'Google Calendar not configured' });
+        }
+        const chat = await whatsapp_chat_model_1.default.findById(conn.chatId);
+        const patientPhone = chat?.contact_phone || '';
+        const eventId = parameters.event_id;
+        if (!eventId) {
+            return JSON.stringify({ error: 'event_id is required' });
+        }
+        const cancelled = await google_calendar_service_1.default.cancelReservation(tenant._id.toString(), eventId, patientPhone);
+        if (cancelled) {
+            // Update local DB
+            const appt = await appointment_model_1.default.findOneAndUpdate({ google_event_id: eventId, tenant_id: session.tenant_id }, { status: 'cancelled', cancelled_at: new Date() }).lean();
+            // SMS notification to doctor (fire-and-forget)
+            const smsSettings = tenant.settings?.whatsapp_agent;
+            if (appt && smsSettings?.sms_notification_enabled && smsSettings.sms_notification_phones?.length) {
+                const tz = gcal.timezone || 'Europe/Istanbul';
+                netgsm_service_1.default.notifyAppointmentCancelled({
+                    phones: smsSettings.sms_notification_phones,
+                    patientName: appt.patient_name,
+                    patientPhone,
+                    date: appt.start_time.toLocaleDateString('tr-TR', { day: 'numeric', month: 'long', weekday: 'long', timeZone: tz }),
+                    time: appt.start_time.toLocaleTimeString('tr-TR', { hour: '2-digit', minute: '2-digit', timeZone: tz }),
+                }).catch(err => logger_1.default.error('SMS notification failed (cancel)', { error: err.message }));
+            }
+        }
+        return JSON.stringify({ cancelled, event_id: eventId });
+    }
+    async toolRescheduleReservation(conn, parameters) {
+        const session = await whatsapp_session_model_1.default.findById(conn.sessionId);
+        if (!session)
+            return JSON.stringify({ error: 'Session not found' });
+        const tenant = await tenant_model_1.default.findById(session.tenant_id);
+        if (!tenant)
+            return JSON.stringify({ error: 'Tenant not found' });
+        const gcal = tenant.settings?.whatsapp_agent?.google_calendar;
+        if (!gcal?.connected || !gcal?.calendar_id) {
+            return JSON.stringify({ error: 'Google Calendar not configured' });
+        }
+        const chat = await whatsapp_chat_model_1.default.findById(conn.chatId);
+        const patientPhone = chat?.contact_phone || '';
+        const patientName = parameters.patient_name || chat?.contact_name || 'Bilinmeyen Hasta';
+        const oldEventId = parameters.old_event_id;
+        const newIsoStart = parameters.new_iso_start;
+        const newIsoEnd = parameters.new_iso_end;
+        const notes = parameters.notes || '';
+        if (!oldEventId) {
+            return JSON.stringify({ error: 'old_event_id is required' });
+        }
+        if (!newIsoStart || !newIsoEnd) {
+            return JSON.stringify({ error: 'new_iso_start and new_iso_end are required' });
+        }
+        // Fetch old appointment info for SMS before cancelling
+        const oldAppt = await appointment_model_1.default.findOne({ google_event_id: oldEventId, tenant_id: session.tenant_id }).lean();
+        // Step 1: Cancel old reservation
+        try {
+            await google_calendar_service_1.default.cancelReservation(tenant._id.toString(), oldEventId, patientPhone);
+            appointment_model_1.default.updateOne({ google_event_id: oldEventId, tenant_id: session.tenant_id }, { status: 'cancelled', cancelled_at: new Date() }).catch(err => logger_1.default.error('Failed to update appointment status', { error: err.message }));
+            logger_1.default.info('Reschedule: old reservation cancelled', { oldEventId, sessionId: conn.sessionId });
+        }
+        catch (err) {
+            return JSON.stringify({ error: `Eski randevu iptal edilemedi: ${err.message}` });
+        }
+        // Step 2: Create new reservation
+        const appointmentId = new mongoose_1.default.Types.ObjectId();
+        try {
+            const result = await google_calendar_service_1.default.reserveSlot(tenant._id.toString(), { iso_start: newIsoStart, iso_end: newIsoEnd, patient_name: patientName, patient_phone: patientPhone, notes, appointment_id: appointmentId.toString() });
+            appointment_model_1.default.create({
+                _id: appointmentId,
+                tenant_id: session.tenant_id,
+                chat_id: session.chat_id,
+                session_id: session._id,
+                google_event_id: result.event_id,
+                patient_name: patientName,
+                patient_phone: patientPhone,
+                start_time: new Date(result.start),
+                end_time: new Date(result.end),
+                duration_minutes: gcal.appointment_duration_minutes,
+                notes,
+                status: 'scheduled',
+            }).catch(err => logger_1.default.error('Failed to persist rescheduled appointment', { error: err.message }));
+            // SMS notification to doctor (fire-and-forget)
+            const smsSettings = tenant.settings?.whatsapp_agent;
+            if (smsSettings?.sms_notification_enabled && smsSettings.sms_notification_phones?.length) {
+                const tz = gcal.timezone || 'Europe/Istanbul';
+                const newStartDt = new Date(result.start);
+                netgsm_service_1.default.notifyAppointmentRescheduled({
+                    phones: smsSettings.sms_notification_phones,
+                    patientName,
+                    patientPhone,
+                    oldDate: oldAppt
+                        ? oldAppt.start_time.toLocaleDateString('tr-TR', { day: 'numeric', month: 'long', weekday: 'long', timeZone: tz })
+                        : 'Bilinmiyor',
+                    oldTime: oldAppt
+                        ? oldAppt.start_time.toLocaleTimeString('tr-TR', { hour: '2-digit', minute: '2-digit', timeZone: tz })
+                        : '',
+                    newDate: newStartDt.toLocaleDateString('tr-TR', { day: 'numeric', month: 'long', weekday: 'long', timeZone: tz }),
+                    newTime: newStartDt.toLocaleTimeString('tr-TR', { hour: '2-digit', minute: '2-digit', timeZone: tz }),
+                    detailUrl: `${config_1.default.google.frontendUrl}/appointments/${appointmentId}`,
+                }).catch(err => logger_1.default.error('SMS notification failed (reschedule)', { error: err.message }));
+            }
+            return JSON.stringify({
+                rescheduled: true,
+                old_event_id: oldEventId,
+                new_event_id: result.event_id,
+                start: result.start,
+                end: result.end,
+                patient_name: patientName,
+            });
+        }
+        catch (err) {
+            return JSON.stringify({ error: `Eski randevu iptal edildi ancak yeni randevu oluşturulamadı: ${err.message}. Lütfen tekrar deneyin.` });
+        }
+    }
+    async toolCheckPatientHistory(conn, _parameters) {
+        const session = await whatsapp_session_model_1.default.findById(conn.sessionId);
+        if (!session)
+            return JSON.stringify({ error: 'Session not found' });
+        const chat = await whatsapp_chat_model_1.default.findById(conn.chatId);
+        const patientPhone = chat?.contact_phone || '';
+        if (!patientPhone) {
+            return JSON.stringify({ error: 'Patient phone not available' });
+        }
+        const tenantId = session.tenant_id;
+        // Find all chats for this patient phone under this tenant
+        const patientChats = await whatsapp_chat_model_1.default.find({ tenant_id: tenantId, contact_phone: patientPhone }, { _id: 1 }).lean();
+        const chatIds = patientChats.map(c => c._id);
+        // Parallel queries
+        const [contactProfile, appointments, operatorRequests, sessions] = await Promise.all([
+            // Contact profile
+            whatsapp_contact_profile_model_1.default.findOne({ tenant_id: tenantId, phone: patientPhone }, { display_name: 1, notes: 1, tags: 1, ai_summary: 1, preferred_language: 1, metadata: 1, first_seen_at: 1, last_seen_at: 1, total_sessions: 1, total_messages: 1 }).lean(),
+            // Appointments: last 10 (any status)
+            appointment_model_1.default.find({ tenant_id: tenantId, patient_phone: patientPhone }, { start_time: 1, end_time: 1, duration_minutes: 1, status: 1, notes: 1, cancelled_at: 1, createdAt: 1 }).sort({ start_time: -1 }).limit(10).lean(),
+            // Operator requests (photo reviews etc.): last 10
+            operator_request_model_1.default.find({ tenant_id: tenantId, chat_id: { $in: chatIds } }, { ref_code: 1, request_type: 1, status: 1, operator_response: 1, forwarded_at: 1, responded_at: 1 }).sort({ createdAt: -1 }).limit(10).lean(),
+            // Past sessions: last 10
+            whatsapp_session_model_1.default.find({ tenant_id: tenantId, chat_id: { $in: chatIds } }, { status: 1, started_at: 1, resolved_at: 1, resolved_by: 1, message_count: 1 }).sort({ started_at: -1 }).limit(10).lean(),
+        ]);
+        const now = new Date();
+        return JSON.stringify({
+            patient_phone: patientPhone,
+            contact_profile: contactProfile ? {
+                display_name: contactProfile.display_name,
+                notes: contactProfile.notes || undefined,
+                tags: contactProfile.tags.length > 0 ? contactProfile.tags : undefined,
+                ai_summary: contactProfile.ai_summary || undefined,
+                preferred_language: contactProfile.preferred_language || undefined,
+                metadata: contactProfile.metadata && Object.keys(contactProfile.metadata).length > 0 ? contactProfile.metadata : undefined,
+                first_seen: contactProfile.first_seen_at?.toISOString().split('T')[0],
+                last_seen: contactProfile.last_seen_at?.toISOString().split('T')[0],
+                total_sessions: contactProfile.total_sessions,
+                total_messages: contactProfile.total_messages,
+            } : null,
+            appointments: appointments.map(a => ({
+                date: a.start_time.toISOString().split('T')[0],
+                time: a.start_time.toISOString().split('T')[1].substring(0, 5),
+                duration_minutes: a.duration_minutes,
+                status: a.status,
+                notes: a.notes || undefined,
+                is_upcoming: a.start_time > now && a.status === 'scheduled',
+            })),
+            operator_requests: operatorRequests.map(r => ({
+                ref_code: r.ref_code,
+                type: r.request_type,
+                status: r.status,
+                response: r.operator_response || undefined,
+                date: r.forwarded_at.toISOString().split('T')[0],
+            })),
+            total_sessions: sessions.length,
+            total_appointments: appointments.length,
+            total_cancelled: appointments.filter(a => a.status === 'cancelled').length,
+            upcoming_appointments: appointments.filter(a => a.start_time > now && a.status === 'scheduled').length,
+        });
+    }
+    // ─── Operator Workflow ────────────────────────────────────
+    /**
+     * Inject the operator's (doctor's) response into the patient's AI session.
+     * Creates a new WS connection if the previous one timed out during the wait.
+     */
+    async injectOperatorResponse(params) {
+        const { tenantId, sessionId, chatId, operatorResponse, refCode, hasDocument } = params;
+        // Reload session and chat from DB
+        const session = await whatsapp_session_model_1.default.findById(sessionId);
+        if (!session || session.status === 'resolved') {
+            logger_1.default.warn('Session not found or already resolved for operator response', { sessionId, refCode });
+            return;
+        }
+        const chat = await whatsapp_chat_model_1.default.findById(chatId);
+        if (!chat) {
+            logger_1.default.warn('Chat not found for operator response', { chatId, refCode });
+            return;
+        }
+        // Resolve agent ID
+        const tenant = await tenant_model_1.default.findById(tenantId).lean();
+        if (!tenant)
+            return;
+        const agentId = await resolveAgentId(tenant);
+        if (!agentId) {
+            logger_1.default.warn('No active agent for operator response injection', { tenantId, refCode });
+            return;
+        }
+        const unipileChatId = chat.unipile_chat_id;
+        let conn = this.connections.get(unipileChatId);
+        const isAlive = conn && conn.ws.readyState === ws_1.default.OPEN && conn.ready;
+        let isNewConnection = false;
+        if (!isAlive) {
+            // Connection died while waiting for doctor — recreate it
+            if (conn) {
+                if (conn.pingTimer) {
+                    clearInterval(conn.pingTimer);
+                    conn.pingTimer = null;
+                }
+                conn.intentionallyClosed = true;
+                try {
+                    conn.ws.close();
+                }
+                catch { /* ignore */ }
+                this.connections.delete(unipileChatId);
+            }
+            try {
+                conn = await this.createConnection(agentId, chat, session, { isReconnect: true });
+                this.connections.set(unipileChatId, conn);
+                isNewConnection = true;
+            }
+            catch (err) {
+                logger_1.default.error('Failed to create EL connection for operator response', {
+                    error: err.message,
+                    sessionId,
+                    refCode,
+                });
+                return;
+            }
+        }
+        conn.lastActivity = Date.now();
+        await whatsapp_session_model_1.default.updateOne({ _id: session._id }, { elevenlabs_last_interaction_at: new Date() });
+        // Send chat context as backup (continuation directive handles it in system prompt if enabled)
+        if (isNewConnection) {
+            await this.sendChatContext(conn, chat._id.toString(), sessionId);
+        }
+        // Inject the operator's response
+        const docNote = hasDocument
+            ? ' Ayrıca hastaya bir belge/dosya da gönderildi — hastaya belgeyi kontrol etmesini söyle.'
+            : '';
+        conn.ws.send(JSON.stringify({
+            type: 'contextual_update',
+            text: `Estetisyen yanıt verdi (Ref: ${refCode}): ${operatorResponse}.${docNote} Bu bilgiyi hastaya doğal ve sıcak bir şekilde ilet.`,
+        }));
+        // Send user_message to prod AI to generate a response
+        conn.ws.send(JSON.stringify({
+            type: 'user_message',
+            text: 'Estetisyenden yanıt geldi.',
+        }));
+        // Clear awaiting_operator flag
+        session.awaiting_operator = false;
+        await session.save();
+        logger_1.default.info('Injected operator response into AI session', {
+            sessionId,
+            refCode,
+            isNewConnection,
+            responsePreview: operatorResponse.substring(0, 100),
+        });
+    }
+    /**
+     * Sweep expired operator requests: set to 'expired', clear awaiting_operator,
+     * and notify the AI to inform the patient.
+     */
+    async sweepExpiredOperatorRequests() {
+        const expiredRequests = await operator_request_model_1.default.find({
+            status: 'pending',
+            expires_at: { $lt: new Date() },
+        }).lean();
+        for (const request of expiredRequests) {
+            await operator_request_model_1.default.updateOne({ _id: request._id }, { status: 'expired' });
+            // Clear awaiting_operator on the session
+            const session = await whatsapp_session_model_1.default.findById(request.session_id);
+            if (session && session.status === 'active') {
+                session.awaiting_operator = false;
+                await session.save();
+                // Try to notify AI
+                const chat = await whatsapp_chat_model_1.default.findById(request.chat_id);
+                if (chat) {
+                    const conn = this.connections.get(chat.unipile_chat_id);
+                    if (conn && conn.ws.readyState === ws_1.default.OPEN && conn.ready) {
+                        conn.ws.send(JSON.stringify({
+                            type: 'contextual_update',
+                            text: `Doktordan yanıt alınamadı (Ref: ${request.ref_code} süresi doldu). Hastaya durumu bildir ve daha sonra dönüş yapılacağını söyle.`,
+                        }));
+                        conn.ws.send(JSON.stringify({
+                            type: 'user_message',
+                            text: 'Doktordan henüz yanıt gelmedi.',
+                        }));
+                    }
+                }
+            }
+            logger_1.default.info('Expired operator request', {
+                refCode: request.ref_code,
+                sessionId: request.session_id,
+            });
+        }
+        if (expiredRequests.length > 0) {
+            logger_1.default.info('Operator request expiry sweep complete', { expired: expiredRequests.length });
+        }
+    }
+    cleanupIdle() {
+        const now = Date.now();
+        for (const [unipileChatId, conn] of this.connections) {
+            if (now - conn.lastActivity > this.idleTimeoutMs) {
+                logger_1.default.info('Closing idle EL connection', { unipileChatId, sessionId: conn.sessionId });
+                if (conn.pingTimer) {
+                    clearInterval(conn.pingTimer);
+                    conn.pingTimer = null;
+                }
+                conn.intentionallyClosed = true;
+                conn.ws.close();
+                this.connections.delete(unipileChatId);
+            }
+        }
+    }
+    getActiveConnectionCount() {
+        return this.connections.size;
+    }
+    shutdown() {
+        if (this.cleanupInterval)
+            clearInterval(this.cleanupInterval);
+        if (this.sweepInterval)
+            clearInterval(this.sweepInterval);
+        if (this.inactivitySweepInterval)
+            clearInterval(this.inactivitySweepInterval);
+        if (this.costSweepInterval)
+            clearInterval(this.costSweepInterval);
+        for (const [, timer] of this.sessionTimers) {
+            clearTimeout(timer);
+        }
+        this.sessionTimers.clear();
+        for (const [, timer] of this.messageBufferTimers) {
+            clearTimeout(timer);
+        }
+        this.messageBufferTimers.clear();
+        for (const [, conn] of this.connections) {
+            if (conn.pingTimer)
+                clearInterval(conn.pingTimer);
+            conn.intentionallyClosed = true;
+            conn.ws.close();
+        }
+        this.connections.clear();
+        logger_1.default.info('WhatsAppAgentService shut down');
+    }
+}
+const whatsappAgentService = new WhatsAppAgentService();
+exports.default = whatsappAgentService;
+//# sourceMappingURL=whatsapp-agent.service.js.map