elevenlabs-webhook-nodejs 1.0.0

package/src/services/whatsapp-agent.service.ts

@@ -0,0 +1,2479 @@
+import mongoose from 'mongoose';
+import WebSocket from 'ws';
+import elevenlabsService from './elevenlabs.service';
+import unipileService from './unipile.service';
+import WhatsAppChat from '../modules/whatsapp/whatsapp-chat.model';
+import WhatsAppSession from '../modules/whatsapp/whatsapp-session.model';
+import WhatsAppMessage from '../modules/whatsapp/whatsapp-message.model';
+import type { IWhatsAppChat } from '../modules/whatsapp/whatsapp-chat.model';
+import type { IWhatsAppSession } from '../modules/whatsapp/whatsapp-session.model';
+import Appointment from '../modules/whatsapp/appointment.model';
+import Tenant from '../modules/tenants/tenant.model';
+import Agent from '../modules/agents/agent.model';
+import type { ITenant } from '../modules/tenants/tenant.model';
+import WhatsAppContactProfile from '../modules/whatsapp/whatsapp-contact-profile.model';
+import OperatorRequest from '../modules/whatsapp/operator-request.model';
+import googleCalendarService from './google-calendar.service';
+import netgsmService from './netgsm.service';
+import Lead from '../modules/leads/lead.model';
+import { createAIService } from './ai';
+import OpenAI from 'openai';
+import config from '../config';
+import logger from '../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: ITenant | { settings?: ITenant['settings'] }): Promise<string> {
+  const agentObjId = tenant.settings?.whatsapp_agent?.agent_id;
+  if (!agentObjId) return '';
+  const agent = await Agent.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;
+
+interface ActiveConnection {
+  ws: WebSocket;
+  chatId: string;
+  sessionId: string;
+  unipileChatId: string;
+  agentId: string;
+  lastActivity: number;
+  conversationId: string | null;
+  ready: boolean;
+  intentionallyClosed: boolean;
+  pingTimer: NodeJS.Timeout | null;
+}
+
+// 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 {
+  private connections: Map<string, ActiveConnection> = new Map(); // key: unipileChatId
+  private sessionTimers: Map<string, NodeJS.Timeout> = new Map(); // key: sessionId
+  private messageBufferTimers: Map<string, NodeJS.Timeout> = new Map(); // key: sessionId
+  private idleTimeoutMs: number = 2 * 60 * 60 * 1000; // 2 hours (matches session inactivity timeout)
+  private cleanupInterval: NodeJS.Timeout | null = null;
+  private sweepInterval: NodeJS.Timeout | null = null;
+  private inactivitySweepInterval: NodeJS.Timeout | null = null;
+  private costSweepInterval: NodeJS.Timeout | null = null;
+
+  async initialize(): Promise<void> {
+    this.cleanupInterval = setInterval(() => this.cleanupIdle(), 60_000);
+    this.sweepInterval = setInterval(() => {
+      this.sweepStuckSessions().catch(err => {
+        logger.error('Stuck session sweep failed', { error: (err as Error).message });
+      });
+    }, 5 * 60_000);
+    this.inactivitySweepInterval = setInterval(() => {
+      this.sweepInactiveSessions().catch(err => {
+        logger.error('Inactive session sweep failed', { error: (err as Error).message });
+      });
+    }, 5 * 60_000);
+    this.costSweepInterval = setInterval(() => {
+      this.sweepConversationCosts().catch(err => {
+        logger.error('Cost sweep failed', { error: (err as Error).message });
+      });
+    }, 10 * 60_000);
+    setInterval(() => {
+      this.sweepExpiredOperatorRequests().catch(err => {
+        logger.error('Operator request expiry sweep failed', { error: (err as Error).message });
+      });
+    }, 15 * 60_000);
+    await this.recoverSessions();
+    logger.info('WhatsAppAgentService initialized');
+  }
+
+  // ─── Session Management ──────────────────────────────────
+
+  async startSession(params: {
+    session: IWhatsAppSession;
+    gracePeriodSeconds: number;
+    agentId: string;
+    tenantId: string;
+  }): Promise<void> {
+    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.info('Session grace period started', {
+      sessionId,
+      chatId: session.chat_id,
+      gracePeriodSeconds,
+      deadline: session.grace_deadline?.toISOString(),
+    });
+  }
+
+  cancelSession(sessionId: string): void {
+    const timer = this.sessionTimers.get(sessionId);
+    if (timer) {
+      clearTimeout(timer);
+      this.sessionTimers.delete(sessionId);
+      logger.info('Session timer cancelled', { sessionId });
+    }
+    this.cancelMessageBuffer(sessionId);
+  }
+
+  private cancelMessageBuffer(sessionId: string): void {
+    const timer = this.messageBufferTimers.get(sessionId);
+    if (timer) {
+      clearTimeout(timer);
+      this.messageBufferTimers.delete(sessionId);
+      logger.debug('Message buffer timer cancelled', { sessionId });
+    }
+  }
+
+  async resolveSessionAsHuman(session: IWhatsAppSession): Promise<void> {
+    this.cancelSession(session._id.toString());
+    session.status = 'resolved';
+    session.resolved_by = 'human';
+    session.resolved_at = new Date();
+    await session.save();
+
+    await WhatsAppChat.updateOne(
+      { _id: session.chat_id },
+      { active_session_id: null }
+    );
+    logger.info('Session resolved by human response', { sessionId: session._id });
+
+    this.updateContactProfileSummary(session._id.toString()).catch(err => {
+      logger.error('Profile summary update failed after human resolve', { error: (err as Error).message });
+    });
+    this.generateSessionLabels(session._id.toString()).catch(err => {
+      logger.error('Session labelling failed after human resolve', { error: (err as Error).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: {
+    tenantId: string;
+    agentId: string;
+    session: IWhatsAppSession;
+  }): Promise<{ pendingCount: number }> {
+    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.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.findById(tenantId).lean();
+    if (tenant && !this.isWithinAiShift(tenant)) {
+      logger.info('Skipping AI replay — outside AI shift hours', { sessionId });
+      return { pendingCount: 0 };
+    }
+
+    // Simple session-scoped query — no backwards scanning
+    const pendingMessages = await WhatsAppMessage.find({
+      session_id: session._id,
+      sender: 'contact',
+    }).sort({ createdAt: 1 }).lean();
+
+    if (pendingMessages.length === 0) {
+      logger.info('No pending messages to replay', { sessionId });
+      return { pendingCount: 0 };
+    }
+
+    const combinedText = pendingMessages.map(m => m.text).join('\n');
+    logger.info('Replaying pending messages for AI response', {
+      sessionId,
+      messageCount: pendingMessages.length,
+    });
+
+    const chat = await WhatsAppChat.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.
+   */
+  private async onMessageBufferExpired(
+    sessionId: string,
+    tenantId: string,
+    agentId: string,
+  ): Promise<void> {
+    this.messageBufferTimers.delete(sessionId);
+
+    const session = await WhatsAppSession.findById(sessionId);
+    if (!session || session.status !== 'active' || session.taken_over_by) {
+      logger.debug('Buffer expired but session not active for AI', { sessionId });
+      return;
+    }
+
+    const chat = await WhatsAppChat.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.info('Buffer expired but skipping AI — human has previously messaged', { sessionId });
+      return;
+    }
+
+    // Skip AI if outside shift hours
+    const tenant = await Tenant.findById(session.tenant_id).lean();
+    if (tenant && !this.isWithinAiShift(tenant)) {
+      logger.info('Buffer expired but outside AI shift hours — skipping AI', { sessionId });
+      return;
+    }
+
+    // Find the last AI response in this session
+    const lastAiMsg = await WhatsAppMessage.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: Record<string, unknown> = {
+      session_id: session._id,
+      sender: 'contact',
+    };
+    if (lastAiMsg) {
+      query.createdAt = { $gt: lastAiMsg.createdAt };
+    }
+
+    const pendingMessages = await WhatsAppMessage.find(query).sort({ createdAt: 1 }).lean();
+    if (pendingMessages.length === 0) {
+      logger.debug('Buffer expired but no pending messages', { sessionId });
+      return;
+    }
+
+    const combinedText = pendingMessages.map(m => m.text).join('\n');
+    logger.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,
+    });
+  }
+
+  private async onGracePeriodExpired(
+    sessionId: string,
+    agentId: string,
+    tenantId: string
+  ): Promise<void> {
+    const session = await WhatsAppSession.findById(sessionId);
+    if (!session) return;
+
+    if (session.status !== 'waiting') {
+      logger.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 WhatsAppChat.updateOne(
+        { _id: session.chat_id },
+        { active_session_id: null }
+      );
+      logger.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 WhatsAppChat.updateOne(
+        { _id: session.chat_id },
+        { active_session_id: null }
+      );
+      logger.info('Grace period expired but skipping AI — human has previously messaged', { sessionId });
+      return;
+    }
+
+    // Skip AI if outside shift hours
+    const tenant = await Tenant.findById(tenantId).lean();
+    if (tenant && !this.isWithinAiShift(tenant)) {
+      session.status = 'resolved';
+      session.resolved_by = 'manual';
+      session.resolved_at = new Date();
+      await session.save();
+      await WhatsAppChat.updateOne(
+        { _id: session.chat_id },
+        { active_session_id: null }
+      );
+      logger.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.info('Grace period expired, session now active (AI)', { sessionId, agentId });
+
+    await this.replayPendingMessages({ tenantId, agentId, session });
+  }
+
+  private async recoverSessions(): Promise<void> {
+    const waitingSessions = await WhatsAppSession.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.findById(session.tenant_id).lean();
+      const agentId = tenant ? await resolveAgentId(tenant) : '';
+      const sessionId = session._id.toString();
+
+      if (remaining <= 0) {
+        logger.info('Recovering expired session', { sessionId });
+        await this.onGracePeriodExpired(sessionId, agentId, session.tenant_id.toString());
+      } else {
+        logger.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.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.
+   */
+  private async sweepStuckSessions(): Promise<void> {
+    const stuckSessions = await WhatsAppSession.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.warn('Sweeping stuck session', {
+        sessionId,
+        deadline: session.grace_deadline,
+      });
+
+      const tenant = await Tenant.findById(session.tenant_id).lean();
+      const agentId = tenant ? await resolveAgentId(tenant) : '';
+
+      await this.onGracePeriodExpired(sessionId, agentId, session.tenant_id.toString());
+    }
+
+    if (swept > 0) {
+      logger.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).
+   */
+  private async sweepInactiveSessions(): Promise<void> {
+    const cutoff = new Date(Date.now() - SESSION_INACTIVITY_TIMEOUT_MS);
+
+    const inactiveSessions = await WhatsAppSession.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 WhatsAppChat.findById(session.chat_id);
+      if (chat) {
+        this.closeConnection(chat.unipile_chat_id);
+      }
+
+      // Resolve the session
+      await WhatsAppSession.updateOne(
+        { _id: session._id },
+        {
+          status: 'resolved',
+          resolved_by: 'timeout',
+          resolved_at: new Date(),
+        },
+      );
+
+      // Unlink from chat
+      await WhatsAppChat.updateOne(
+        { _id: session.chat_id, active_session_id: session._id },
+        { active_session_id: null },
+      );
+
+      resolved++;
+      logger.info('Auto-resolved inactive session', {
+        sessionId,
+        chatId: session.chat_id,
+        lastActivity: session.updatedAt,
+      });
+
+      this.updateContactProfileSummary(sessionId).catch(err => {
+        logger.error('Profile summary update failed after inactive sweep', { error: (err as Error).message });
+      });
+      this.generateSessionLabels(sessionId).catch(err => {
+        logger.error('Session labelling failed after inactive sweep', { error: (err as Error).message });
+      });
+    }
+
+    if (resolved > 0) {
+      logger.info('Inactive session sweep complete', { resolved, total: inactiveSessions.length });
+    }
+  }
+
+  /**
+   * Fetch ElevenLabs credits for resolved sessions that have a conversation ID but no cost yet.
+   */
+  private async sweepConversationCosts(): Promise<void> {
+    const sessions = await WhatsAppSession.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 elevenlabsService.getConversation(session.elevenlabs_conversation_id!);
+        const convAny = conv as unknown as { metadata?: { cost?: number } };
+        const cost = convAny.metadata?.cost;
+
+        if (cost != null) {
+          await WhatsAppSession.updateOne(
+            { _id: session._id },
+            { elevenlabs_cost: cost },
+          );
+          updated++;
+        }
+      } catch (err) {
+        const status = (err as { statusCode?: number }).statusCode
+          || (err as { status?: number }).status;
+        if (status === 404) {
+          await WhatsAppSession.updateOne(
+            { _id: session._id },
+            { elevenlabs_cost: 0 },
+          );
+          logger.warn('Conversation not found on ElevenLabs, set cost to 0', {
+            sessionId: session._id,
+            conversationId: session.elevenlabs_conversation_id,
+          });
+        } else {
+          logger.warn('Failed to fetch conversation cost', {
+            sessionId: session._id,
+            conversationId: session.elevenlabs_conversation_id,
+            error: (err as Error).message,
+          });
+        }
+      }
+    }
+
+    if (updated > 0) {
+      logger.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.
+   */
+  private async hasHumanMessageInChat(chatId: string | { toString(): string }): Promise<boolean> {
+    const msg = await WhatsAppMessage.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.
+   */
+  private isWithinAiShift(tenant: ITenant | { settings?: ITenant['settings'] }): boolean {
+    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: Record<string, number> = {
+      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: boolean;
+    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.
+   */
+  private async buildChatContext(
+    chatId: string,
+    currentSessionId: string,
+  ): Promise<string | null> {
+    const messages = await WhatsAppMessage.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 OperatorRequest.find({ session_id: currentSessionId })
+      .sort({ createdAt: 1 })
+      .lean();
+
+    // Build timeline entries: messages + operator request events
+    interface TimelineEntry { at: Date; text: string; }
+    const timeline: TimelineEntry[] = [];
+
+    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 as { ad?: { title?: string; body?: string; source_url?: string }; source?: string; app?: string } | null;
+    if (adCtx) {
+      const adParts: string[] = [];
+      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')}`;
+  }
+
+  private async sendChatContext(
+    conn: ActiveConnection,
+    chatId: string,
+    sessionId: string,
+  ): Promise<void> {
+    const context = await this.buildChatContext(chatId, sessionId);
+    if (!context) return;
+
+    conn.ws.send(JSON.stringify({
+      type: 'contextual_update',
+      text: context,
+    }));
+
+    logger.info('Sent chat history context to ElevenLabs', {
+      sessionId,
+      chatId,
+      contextLength: context.length,
+    });
+  }
+
+  private async triggerAiResponse(params: {
+    tenantId: string;
+    agentId: string;
+    chat: IWhatsAppChat;
+    session: IWhatsAppSession;
+    messageText: string;
+  }): Promise<void> {
+    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 === WebSocket.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.error('Failed to create EL connection', {
+          error: (err as Error).message,
+          unipileChatId,
+          sessionId,
+        });
+        return;
+      }
+    }
+
+    conn!.lastActivity = Date.now();
+    await WhatsAppSession.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.info('AI triggered', { sessionId, text: messageText.substring(0, 50) });
+  }
+
+  async handleIncomingMessage(params: {
+    tenantId: string;
+    agentId: string;
+    chat: IWhatsAppChat;
+    session: IWhatsAppSession;
+    messageText: string;
+    senderName: string;
+    unipileMessageId?: string;
+    contentType?: string;
+  }): Promise<void> {
+    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 WhatsAppMessage.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.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.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.findById(tenantId).lean();
+    if (tenant && !this.isWithinAiShift(tenant)) {
+      logger.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.error('Message buffer handler failed', {
+          error: (err as Error).message,
+          sessionId,
+        });
+      });
+    }, bufferMs);
+
+    this.messageBufferTimers.set(sessionId, bufferTimer);
+
+    logger.info('Message buffered, AI will respond after pause', {
+      sessionId,
+      bufferMs,
+      text: messageText.substring(0, 50),
+    });
+  }
+
+  // ─── ElevenLabs Connection ────────────────────────────────
+
+  private async buildUserSummary(contactProfileId?: string | null): Promise<{ summary: string; hasMeaningfulContext: boolean }> {
+    if (!contactProfileId) return { summary: '', hasMeaningfulContext: false };
+
+    const profile = await WhatsAppContactProfile.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: string[] = [];
+    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 };
+  }
+
+  private async createConnection(
+    agentId: string,
+    chat: IWhatsAppChat,
+    session: IWhatsAppSession,
+    options?: { isReconnect?: boolean }
+  ): Promise<ActiveConnection> {
+    const sessionId = session._id.toString();
+    let isReconnect = options?.isReconnect || false;
+    logger.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.findById(session.tenant_id).lean();
+      if (!tenant?.enabled_features?.includes('chat_continuity')) {
+        logger.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 WhatsAppMessage.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.info('Built continuation directive for reconnection', {
+        sessionId,
+        directiveLength: continuationDirective.length,
+      });
+    }
+
+    const result = await elevenlabsService.getSignedUrl({ agentId });
+    const signedUrl = (result as { signedUrl?: string }).signedUrl
+      || (result as { signed_url?: string }).signed_url
+      || String(result);
+
+    const separator = signedUrl.includes('?') ? '&' : '?';
+    const wsUrl = `${signedUrl}${separator}textOnly=true`;
+
+    const ws = new WebSocket(wsUrl);
+    const unipileChatId = chat.unipile_chat_id;
+
+    const conn: ActiveConnection = {
+      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<void>((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        ws.close();
+        reject(new Error('ElevenLabs WS initialization timeout (15s)'));
+      }, 15_000);
+
+      ws.on('open', () => {
+        logger.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.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: Buffer) => {
+        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: Record<string, unknown> = {
+                $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 };
+              }
+              WhatsAppSession.updateOne({ _id: session._id }, updateOp).catch(() => {});
+            }
+            conn.ready = true;
+            clearTimeout(timeout);
+            logger.info('ElevenLabs conversation ready', {
+              sessionId,
+              conversationId: convId,
+            });
+            resolve();
+          }
+        } catch (err) {
+          logger.error('Error parsing EL WS init message', { error: (err as Error).message });
+        }
+      });
+    });
+
+    // Start keepalive: TCP ping + EL user_activity to reset inactivity timer
+    conn.pingTimer = setInterval(() => {
+      if (conn.ws.readyState === WebSocket.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: Buffer) => {
+      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.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.error('Client tool call failed', {
+              tool_name,
+              sessionId,
+              error: (err as Error).message,
+            }));
+          return;
+        }
+
+        if (msg.type === 'agent_response') {
+          const responseText =
+            msg.agent_response_event?.agent_response
+            || msg.agent_response;
+          if (responseText) {
+            await WhatsAppSession.updateOne(
+              { _id: session._id },
+              { elevenlabs_last_interaction_at: new Date() }
+            );
+            await this.sendResponse(chat, session, responseText);
+          }
+        }
+      } catch (err) {
+        logger.error('Error handling EL WS message', {
+          error: (err as Error).message,
+          sessionId,
+        });
+      }
+    });
+
+    ws.on('close', (code, reason) => {
+      if (conn.pingTimer) {
+        clearInterval(conn.pingTimer);
+        conn.pingTimer = null;
+      }
+      logger.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.error('ElevenLabs WS error', { error: err.message, sessionId });
+    });
+
+    return conn;
+  }
+
+  private async sendResponse(
+    chat: IWhatsAppChat,
+    session: IWhatsAppSession,
+    text: string
+  ): Promise<void> {
+    try {
+      const tenant = await Tenant.findById(chat.tenant_id).lean();
+      const provider = unipileService.getProviderForTenant(tenant);
+      const result = await unipileService.sendMessage(provider, chat.unipile_chat_id, text);
+      logger.info('AI response sent via bridge', { provider, sessionId: session._id, text: text.substring(0, 50) });
+
+      await WhatsAppMessage.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 WhatsAppChat.updateOne(
+        { _id: chat._id },
+        {
+          $inc: { message_count: 1 },
+          $set: { last_message_at: new Date(), last_message_preview: text.substring(0, 100) },
+        },
+      );
+
+      await WhatsAppSession.updateOne(
+        { _id: session._id },
+        { $inc: { message_count: 1 } },
+      );
+    } catch (err) {
+      logger.error('Failed to send AI response via bridge', {
+        sessionId: session._id,
+        error: (err as Error).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: string): Promise<void> {
+    const session = await WhatsAppSession.findById(sessionId).lean();
+    if (!session || session.message_count < 2) {
+      throw new Error('Session not found or has fewer than 2 messages');
+    }
+
+    const chat = await WhatsAppChat.findById(session.chat_id).lean();
+    if (!chat?.contact_profile_id) {
+      throw new Error('Chat has no linked contact profile');
+    }
+
+    const profile = await WhatsAppContactProfile.findById(chat.contact_profile_id).lean();
+    if (!profile) {
+      throw new Error('Contact profile not found');
+    }
+
+    // Build the transcript from session messages
+    const messages = await WhatsAppMessage.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 = 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: Record<string, string> = { ai_summary: summaryText };
+    if (preferredLanguage) {
+      updateFields.preferred_language = preferredLanguage;
+    }
+
+    await WhatsAppContactProfile.updateOne(
+      { _id: profile._id },
+      { $set: updateFields },
+    );
+    logger.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: string): Promise<void> {
+    logger.info('generateSessionLabels called', { sessionId });
+    const session = await WhatsAppSession.findById(sessionId);
+    if (!session || session.message_count < 2) {
+      logger.info('generateSessionLabels skipped — not enough messages', { sessionId, message_count: session?.message_count });
+      return;
+    }
+
+    const messages = await WhatsAppMessage.find({ session_id: session._id })
+      .sort({ createdAt: 1 }).lean();
+    if (messages.length < 2) {
+      logger.info('generateSessionLabels skipped — fewer than 2 messages found', { sessionId, found: messages.length });
+      return;
+    }
+
+    const chat = await WhatsAppChat.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({ apiKey: config.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: Record<string, unknown> = {};
+    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.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.info('Lead created from WhatsApp session', { sessionId, phone: chat.contact_phone });
+        } catch (err: unknown) {
+          const code = (err as { code?: number }).code;
+          if (code === 11000) {
+            logger.info('Lead already exists for session', { sessionId });
+          } else {
+            throw err;
+          }
+        }
+      }
+    } catch {
+      update.llm_summary = content || null;
+    }
+
+    await WhatsAppSession.updateOne({ _id: session._id }, { $set: update });
+    logger.info('Session labels generated', {
+      sessionId,
+      sentiment: update.sentiment,
+      categories: update.categories,
+    });
+  }
+
+  // ─── Connection Management ────────────────────────────────
+
+  closeConnection(unipileChatId: string): void {
+    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.info('Closed EL connection for chat', { unipileChatId });
+    }
+  }
+
+  // ─── Client Tool Call Handling ───────────────────────────
+
+  private async handleClientToolCall(
+    conn: ActiveConnection,
+    toolCallId: string,
+    toolName: string,
+    parameters: Record<string, unknown>,
+  ): Promise<void> {
+    let result: string;
+    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 as Error).message });
+      isError = true;
+    }
+
+    conn.ws.send(JSON.stringify({
+      type: 'client_tool_result',
+      tool_call_id: toolCallId,
+      result,
+      is_error: isError,
+    }));
+
+    logger.info('Client tool call completed', {
+      toolName,
+      toolCallId,
+      sessionId: conn.sessionId,
+      resultPreview: result.substring(0, 200),
+    });
+  }
+
+  private async toolSendExamplePhoto(conn: ActiveConnection): Promise<string> {
+    const session = await WhatsAppSession.findById(conn.sessionId);
+    if (!session) return JSON.stringify({ error: 'Session not found' });
+
+    const chat = await WhatsAppChat.findById(conn.chatId);
+    if (!chat) return JSON.stringify({ error: 'Chat not found' });
+
+    const tenant = await Tenant.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 = unipileService.getProviderForTenant(tenant);
+
+    try {
+      await unipileService.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 WhatsAppMessage.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.error('Failed to send example photo', { error: (err as Error).message });
+      return JSON.stringify({ sent: false, error: (err as Error).message });
+    }
+
+    logger.info('Sent example photo to patient', { sessionId: conn.sessionId, chatId: conn.chatId });
+    return JSON.stringify({ sent: true });
+  }
+
+  private async toolForwardToOperator(
+    conn: ActiveConnection,
+    parameters: Record<string, unknown>,
+  ): Promise<string> {
+    const session = await WhatsAppSession.findById(conn.sessionId);
+    if (!session || session.status === 'resolved') {
+      return JSON.stringify({ error: 'Session not found or already resolved' });
+    }
+
+    const chat = await WhatsAppChat.findById(conn.chatId);
+    if (!chat) {
+      return JSON.stringify({ error: 'Chat not found' });
+    }
+
+    const tenant = await Tenant.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 WhatsAppMessage.find({
+      session_id: session._id,
+      sender: 'contact',
+      media_type: { $in: FORWARDABLE_TYPES },
+    }).sort({ createdAt: 1 }).lean();
+
+    logger.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 OperatorRequest.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 as string) || '';
+    const provider = unipileService.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 unipileService.forwardMedia(
+              provider,
+              chat.unipile_chat_id,
+              media.unipile_message_id!,
+              operatorPhone,
+              caption,
+            );
+            forwardedOk++;
+          } catch (err) {
+            failedCount++;
+            logger.warn('Failed to forward media to operator', {
+              refCode, index: i + 1, total,
+              messageId: media.unipile_message_id,
+              error: (err as Error).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 unipileService.sendMessage(provider, operatorChatId, caption);
+        }
+      }
+    } catch (err) {
+      logger.error('Failed to forward to operator', { refCode, error: (err as Error).message });
+      return JSON.stringify({ ref_code: refCode, forwarded: false, error: (err as Error).message });
+    }
+
+    // Update failed count on the request
+    if (failedCount > 0) {
+      await OperatorRequest.updateOne(
+        { ref_code: refCode, tenant_id: tenant._id },
+        { $set: { failed_count: failedCount } },
+      );
+    }
+
+    logger.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)` } : {}),
+    });
+  }
+
+  private async toolForwardConversationToOperator(
+    conn: ActiveConnection,
+    parameters: Record<string, unknown>,
+  ): Promise<string> {
+    const session = await WhatsAppSession.findById(conn.sessionId);
+    if (!session || session.status === 'resolved') {
+      return JSON.stringify({ error: 'Session not found or already resolved' });
+    }
+
+    const chat = await WhatsAppChat.findById(conn.chatId);
+    if (!chat) return JSON.stringify({ error: 'Chat not found' });
+
+    const tenant = await Tenant.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 as string) || '';
+    const rawMessages = parameters.patient_messages;
+    const patientMessages: string[] = 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 OperatorRequest.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 = unipileService.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 unipileService.sendMessage(provider, forwardChatId, messageText);
+      }
+    } catch (err) {
+      logger.error('Failed to forward conversation to operator', { refCode, error: (err as Error).message });
+      return JSON.stringify({ ref_code: refCode, forwarded: false, error: (err as Error).message });
+    }
+
+    logger.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: string, prefix: string): Promise<string> {
+    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([
+        OperatorRequest.exists({ ref_code: code, tenant_id: tenantId }),
+        WhatsAppSession.exists({ ref_code: code, tenant_id: tenantId }),
+      ]);
+      if (!inRequest && !inSession) return code;
+    }
+    return `${prefix}-${Date.now().toString(36).slice(-4).toUpperCase()}`;
+  }
+
+  // ─── Outbound Call Tool ──────────────────────────────────
+
+  private async toolCallPatient(
+    conn: ActiveConnection,
+    parameters: Record<string, unknown>,
+  ): Promise<string> {
+    const session = await WhatsAppSession.findById(conn.sessionId);
+    if (!session || session.status === 'resolved') {
+      return JSON.stringify({ error: 'Session not found or already resolved' });
+    }
+
+    const chat = await WhatsAppChat.findById(conn.chatId);
+    if (!chat) {
+      return JSON.stringify({ error: 'Chat not found' });
+    }
+
+    const tenant = await Tenant.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: string | null = null;
+    if (callSettings.outbound_call_agent_id) {
+      const callAgent = await Agent.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 as string) || '';
+    const chatContext = await this.buildChatContext(conn.chatId, conn.sessionId) || '';
+
+    try {
+      const result = await elevenlabsService.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.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.error('Failed to initiate outbound call', {
+        sessionId: conn.sessionId,
+        patientPhone,
+        error: (err as Error).message,
+      });
+      return JSON.stringify({ error: 'Call failed: ' + (err as Error).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.
+   */
+  private parseSipFailure(message: string): string | null {
+    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: Record<number, string> = {
+      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 ──────────────────────────────
+
+  private async toolCheckAvailability(
+    conn: ActiveConnection,
+    parameters: Record<string, unknown>,
+  ): Promise<string> {
+    const session = await WhatsAppSession.findById(conn.sessionId);
+    if (!session) return JSON.stringify({ error: 'Session not found' });
+
+    const tenant = await Tenant.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 as string;
+    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 googleCalendarService.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,
+    });
+  }
+
+  private async toolReserveSlot(
+    conn: ActiveConnection,
+    parameters: Record<string, unknown>,
+  ): Promise<string> {
+    const session = await WhatsAppSession.findById(conn.sessionId);
+    if (!session) return JSON.stringify({ error: 'Session not found' });
+
+    const tenant = await Tenant.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 WhatsAppChat.findById(conn.chatId);
+    const patientName = (parameters.patient_name as string)
+      || chat?.contact_name
+      || 'Bilinmeyen Hasta';
+    const patientPhone = chat?.contact_phone || '';
+    const isoStart = parameters.iso_start as string;
+    const isoEnd = parameters.iso_end as string;
+    const notes = (parameters.notes as string) || '';
+
+    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.Types.ObjectId();
+
+    const result = await googleCalendarService.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.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.error('Failed to persist appointment', { error: (err as Error).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';
+      netgsmService.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.google.frontendUrl}/appointments/${appointmentId}`,
+      }).catch(err => logger.error('SMS notification failed (create)', { error: (err as Error).message }));
+    }
+
+    return JSON.stringify({
+      reserved: true,
+      event_id: result.event_id,
+      start: result.start,
+      end: result.end,
+      patient_name: patientName,
+    });
+  }
+
+  private async toolListReservations(
+    conn: ActiveConnection,
+    _parameters: Record<string, unknown>,
+  ): Promise<string> {
+    const session = await WhatsAppSession.findById(conn.sessionId);
+    if (!session) return JSON.stringify({ error: 'Session not found' });
+
+    const tenant = await Tenant.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 WhatsAppChat.findById(conn.chatId);
+    const patientPhone = chat?.contact_phone || '';
+    if (!patientPhone) {
+      return JSON.stringify({ error: 'Patient phone not available' });
+    }
+
+    const reservations = await googleCalendarService.listReservations(
+      tenant._id.toString(), patientPhone,
+    );
+
+    return JSON.stringify({
+      reservations,
+      count: reservations.length,
+    });
+  }
+
+  private async toolCancelReservation(
+    conn: ActiveConnection,
+    parameters: Record<string, unknown>,
+  ): Promise<string> {
+    const session = await WhatsAppSession.findById(conn.sessionId);
+    if (!session) return JSON.stringify({ error: 'Session not found' });
+
+    const tenant = await Tenant.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 WhatsAppChat.findById(conn.chatId);
+    const patientPhone = chat?.contact_phone || '';
+    const eventId = parameters.event_id as string;
+
+    if (!eventId) {
+      return JSON.stringify({ error: 'event_id is required' });
+    }
+
+    const cancelled = await googleCalendarService.cancelReservation(
+      tenant._id.toString(), eventId, patientPhone,
+    );
+
+    if (cancelled) {
+      // Update local DB
+      const appt = await Appointment.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';
+        netgsmService.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.error('SMS notification failed (cancel)', { error: (err as Error).message }));
+      }
+    }
+
+    return JSON.stringify({ cancelled, event_id: eventId });
+  }
+
+  private async toolRescheduleReservation(
+    conn: ActiveConnection,
+    parameters: Record<string, unknown>,
+  ): Promise<string> {
+    const session = await WhatsAppSession.findById(conn.sessionId);
+    if (!session) return JSON.stringify({ error: 'Session not found' });
+
+    const tenant = await Tenant.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 WhatsAppChat.findById(conn.chatId);
+    const patientPhone = chat?.contact_phone || '';
+    const patientName = (parameters.patient_name as string) || chat?.contact_name || 'Bilinmeyen Hasta';
+    const oldEventId = parameters.old_event_id as string;
+    const newIsoStart = parameters.new_iso_start as string;
+    const newIsoEnd = parameters.new_iso_end as string;
+    const notes = (parameters.notes as string) || '';
+
+    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.findOne(
+      { google_event_id: oldEventId, tenant_id: session.tenant_id },
+    ).lean();
+
+    // Step 1: Cancel old reservation
+    try {
+      await googleCalendarService.cancelReservation(
+        tenant._id.toString(), oldEventId, patientPhone,
+      );
+
+      Appointment.updateOne(
+        { google_event_id: oldEventId, tenant_id: session.tenant_id },
+        { status: 'cancelled', cancelled_at: new Date() },
+      ).catch(err => logger.error('Failed to update appointment status', { error: (err as Error).message }));
+
+      logger.info('Reschedule: old reservation cancelled', { oldEventId, sessionId: conn.sessionId });
+    } catch (err) {
+      return JSON.stringify({ error: `Eski randevu iptal edilemedi: ${(err as Error).message}` });
+    }
+
+    // Step 2: Create new reservation
+    const appointmentId = new mongoose.Types.ObjectId();
+
+    try {
+      const result = await googleCalendarService.reserveSlot(
+        tenant._id.toString(),
+        { iso_start: newIsoStart, iso_end: newIsoEnd, patient_name: patientName, patient_phone: patientPhone, notes, appointment_id: appointmentId.toString() },
+      );
+
+      Appointment.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.error('Failed to persist rescheduled appointment', { error: (err as Error).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);
+        netgsmService.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.google.frontendUrl}/appointments/${appointmentId}`,
+        }).catch(err => logger.error('SMS notification failed (reschedule)', { error: (err as Error).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 as Error).message}. Lütfen tekrar deneyin.` });
+    }
+  }
+
+  private async toolCheckPatientHistory(
+    conn: ActiveConnection,
+    _parameters: Record<string, unknown>,
+  ): Promise<string> {
+    const session = await WhatsAppSession.findById(conn.sessionId);
+    if (!session) return JSON.stringify({ error: 'Session not found' });
+
+    const chat = await WhatsAppChat.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 WhatsAppChat.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
+      WhatsAppContactProfile.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.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
+      OperatorRequest.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
+      WhatsAppSession.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: {
+    tenantId: string;
+    sessionId: string;
+    chatId: string;
+    operatorResponse: string;
+    refCode: string;
+    hasDocument?: boolean;
+  }): Promise<void> {
+    const { tenantId, sessionId, chatId, operatorResponse, refCode, hasDocument } = params;
+
+    // Reload session and chat from DB
+    const session = await WhatsAppSession.findById(sessionId);
+    if (!session || session.status === 'resolved') {
+      logger.warn('Session not found or already resolved for operator response', { sessionId, refCode });
+      return;
+    }
+
+    const chat = await WhatsAppChat.findById(chatId);
+    if (!chat) {
+      logger.warn('Chat not found for operator response', { chatId, refCode });
+      return;
+    }
+
+    // Resolve agent ID
+    const tenant = await Tenant.findById(tenantId).lean();
+    if (!tenant) return;
+    const agentId = await resolveAgentId(tenant);
+    if (!agentId) {
+      logger.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 === WebSocket.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.error('Failed to create EL connection for operator response', {
+          error: (err as Error).message,
+          sessionId,
+          refCode,
+        });
+        return;
+      }
+    }
+
+    conn!.lastActivity = Date.now();
+    await WhatsAppSession.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.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.
+   */
+  private async sweepExpiredOperatorRequests(): Promise<void> {
+    const expiredRequests = await OperatorRequest.find({
+      status: 'pending',
+      expires_at: { $lt: new Date() },
+    }).lean();
+
+    for (const request of expiredRequests) {
+      await OperatorRequest.updateOne(
+        { _id: request._id },
+        { status: 'expired' },
+      );
+
+      // Clear awaiting_operator on the session
+      const session = await WhatsAppSession.findById(request.session_id);
+      if (session && session.status === 'active') {
+        session.awaiting_operator = false;
+        await session.save();
+
+        // Try to notify AI
+        const chat = await WhatsAppChat.findById(request.chat_id);
+        if (chat) {
+          const conn = this.connections.get(chat.unipile_chat_id);
+          if (conn && conn.ws.readyState === WebSocket.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.info('Expired operator request', {
+        refCode: request.ref_code,
+        sessionId: request.session_id,
+      });
+    }
+
+    if (expiredRequests.length > 0) {
+      logger.info('Operator request expiry sweep complete', { expired: expiredRequests.length });
+    }
+  }
+
+  private cleanupIdle(): void {
+    const now = Date.now();
+    for (const [unipileChatId, conn] of this.connections) {
+      if (now - conn.lastActivity > this.idleTimeoutMs) {
+        logger.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(): number {
+    return this.connections.size;
+  }
+
+  shutdown(): void {
+    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.info('WhatsAppAgentService shut down');
+  }
+}
+
+const whatsappAgentService = new WhatsAppAgentService();
+export default whatsappAgentService;