evaldoc 1.0.0

package/functions/src/llm.js

@@ -0,0 +1,271 @@
+const OpenAI = require('openai');
+const { GoogleGenerativeAI } = require('@google/generative-ai');
+
+/**
+ * Retry wrapper with exponential backoff for transient API errors.
+ * Retries up to maxRetries times (so maxRetries+1 total attempts).
+ * Only retries on network errors, 429 rate limits, and 5xx server errors.
+ * Does NOT retry on 4xx client errors (except 429).
+ */
+async function withRetry(fn, { maxRetries = 2, baseDelayMs = 1000, label = 'LLM' } = {}) {
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      const status = error.status || error.statusCode || (error.response && error.response.status);
+      const isRateLimit = status === 429;
+      const isServerError = status >= 500 && status < 600;
+      const isNetworkError = !status && (
+        error.code === 'ECONNRESET' ||
+        error.code === 'ECONNREFUSED' ||
+        error.code === 'ETIMEDOUT' ||
+        error.code === 'ENOTFOUND' ||
+        error.code === 'EAI_AGAIN' ||
+        error.message === 'Network Error' ||
+        error.type === 'system'
+      );
+      const isTransient = isRateLimit || isServerError || isNetworkError;
+
+      if (!isTransient || attempt === maxRetries) {
+        throw error;
+      }
+
+      const delayMs = baseDelayMs * Math.pow(2, attempt); // 1s, 2s
+      console.log(`⏳ [${label}] Transient error (${error.message}), retrying in ${delayMs}ms (attempt ${attempt + 1}/${maxRetries})...`);
+      await new Promise(resolve => setTimeout(resolve, delayMs));
+    }
+  }
+}
+
+// Initialize clients (lazy loaded when needed)
+let deepseekClient = null;
+let geminiClient = null;
+
+function getDeepSeekClient() {
+  if (!deepseekClient && process.env.DEEPSEEK_API_KEY) {
+    deepseekClient = new OpenAI({
+      apiKey: process.env.DEEPSEEK_API_KEY,
+      baseURL: 'https://api.deepseek.com'
+    });
+  }
+  return deepseekClient;
+}
+
+function getGeminiClient() {
+  if (!geminiClient && process.env.GEMINI_API_KEY) {
+    geminiClient = new GoogleGenerativeAI(process.env.GEMINI_API_KEY);
+  }
+  return geminiClient;
+}
+
+function buildSystemPrompt(topicConfig, provider, doctorExamples) {
+  const providerName = provider.displayName || 'the clinic';
+  const specialty = provider.specialty || 'healthcare';
+
+  let prompt = `You are a knowledgeable and helpful medical information assistant for ${providerName}, a ${specialty} provider. Your role is to provide accurate, educational health information to help patients understand their health better.
+
+YOUR PRIMARY GOAL: Be as helpful as possible while staying within safe boundaries.
+
+WHAT YOU SHOULD DO:
+- Provide clear, detailed explanations of medical conditions, symptoms, and treatments
+- Explain what medications do, their common side effects, and general usage information
+- Share evidence-based health education about ${topicConfig.title}
+- Help patients prepare for medical appointments with relevant questions to ask
+- Explain medical terms and procedures in simple language
+- Provide general wellness and preventive health information
+- Discuss common causes and risk factors for health conditions
+
+SAFETY BOUNDARIES (important but not overly restrictive):
+- Don't make specific diagnoses for individuals (you can discuss what conditions generally involve)
+- Don't prescribe specific medications or tell people to start/stop their medications
+- Don't provide exact dosing instructions (but you can explain general dosing concepts)
+- For urgent symptoms (chest pain, difficulty breathing, severe bleeding), emphasize seeking immediate care
+- Remind patients that this is educational information, and they should discuss specifics with ${providerName}
+
+RESPONSE STYLE:
+- Be conversational and warm, not overly clinical or cautious
+- Provide 3-4 sentences of helpful information
+- Include practical insights patients can use
+- End with a brief reminder to consult ${providerName} for personalized guidance
+
+COLLECTING CONTACT INFORMATION:
+- In your FIRST or SECOND response strictly, naturally ask for the patient's name and phone number or email
+- Example: "By the way, what's your name? And could you share a phone number or email where ${providerName} can follow up with you if needed?"
+- Make it conversational, not formal - like a friendly receptionist would ask
+- Only ask once - if the patient doesn't provide it or declines, continue normally
+- If the patient shares contact info (email or phone number), acknowledge it briefly and continue
+
+Provider Context:
+- Provider: ${providerName}
+- Specialty: ${specialty}
+- Topic: ${topicConfig.title}
+
+Remember: You're here to educate and empower patients with knowledge, not to replace medical consultation.`;
+
+  // Inject doctor examples for personalized responses (Pillar 2 - Component 5)
+  if (doctorExamples && doctorExamples.length > 0) {
+    prompt += `\n\nIMPORTANT - DOCTOR'S STYLE GUIDE:
+Here are examples of how ${providerName} actually responds to patients. Match their tone, level of detail, and communication style:`;
+    doctorExamples.slice(0, 3).forEach((ex, i) => {
+      prompt += `\n\nExample ${i + 1}:
+Patient: ${ex.patientMessage}
+${providerName}: ${ex.doctorResponse}`;
+    });
+    prompt += `\n\nUse these examples to calibrate your response style to match ${providerName}'s voice.`;
+  }
+
+  return prompt;
+}
+
+
+async function callDeepSeek({ topicConfig, message, provider, conversationHistory, doctorExamples }) {
+  const client = getDeepSeekClient();
+  if (!client) throw new Error('DeepSeek API key not configured');
+
+  const systemPrompt = buildSystemPrompt(topicConfig, provider, doctorExamples);
+
+  // Build messages array: system prompt + conversation history + current message
+  const messages = [{ role: 'system', content: systemPrompt }];
+
+  if (conversationHistory && conversationHistory.length > 0) {
+    for (const msg of conversationHistory) {
+      messages.push({
+        role: msg.role === 'user' ? 'user' : 'assistant',
+        content: msg.content
+      });
+    }
+  }
+
+  messages.push({ role: 'user', content: message });
+
+  const response = await client.chat.completions.create({
+    model: 'deepseek-chat',
+    messages,
+    max_tokens: 300,
+    temperature: 0.4,
+    top_p: 0.9
+  });
+
+  const content = response &&
+    Array.isArray(response.choices) &&
+    response.choices[0] &&
+    response.choices[0].message &&
+    response.choices[0].message.content;
+  if (typeof content !== 'string' || !content.trim()) {
+    throw new Error('DeepSeek returned an empty or malformed response');
+  }
+  return content.trim();
+}
+
+async function callGemini({ topicConfig, message, provider, conversationHistory, doctorExamples }) {
+  const client = getGeminiClient();
+  if (!client) throw new Error('Gemini API key not configured');
+
+  const systemPrompt = buildSystemPrompt(topicConfig, provider, doctorExamples);
+
+  const model = client.getGenerativeModel({
+    model: 'gemini-2.5-flash',
+    systemInstruction: systemPrompt
+  });
+
+  // Build multi-turn contents: conversation history + current message
+  const contents = [];
+
+  if (conversationHistory && conversationHistory.length > 0) {
+    for (const msg of conversationHistory) {
+      contents.push({
+        role: msg.role === 'user' ? 'user' : 'model',
+        parts: [{ text: msg.content }]
+      });
+    }
+  }
+
+  contents.push({ role: 'user', parts: [{ text: message }] });
+
+  const result = await model.generateContent({
+    contents,
+    generationConfig: {
+      maxOutputTokens: 300,
+      temperature: 0.4,
+      topP: 0.9
+    }
+  });
+
+  const text = result && result.response && typeof result.response.text === 'function'
+    ? result.response.text()
+    : null;
+  if (typeof text !== 'string' || !text.trim()) {
+    throw new Error('Gemini returned an empty or malformed response');
+  }
+  return text.trim();
+}
+
+function generateFallbackResponse({ topicConfig, message, provider }) {
+  const providerName = provider.displayName || 'the clinic';
+  return `I can provide general information about ${topicConfig.title}. However, for specific medical questions or concerns, please contact ${providerName} directly. They can provide personalized guidance based on your individual situation.`;
+}
+
+async function generateResponse({ topicConfig, message, provider, conversationHistory, doctorExamples }) {
+  const historyLen = (conversationHistory && conversationHistory.length) || 0;
+  const examplesLen = (doctorExamples && doctorExamples.length) || 0;
+
+  console.log('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+  console.log('🤖 LLM REQUEST');
+  console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+  console.log('📝 User Message:', message.substring(0, 100) + (message.length > 100 ? '...' : ''));
+  console.log('🏥 Provider:', provider.displayName || 'Unknown');
+  console.log('📋 Topic:', topicConfig.title || 'General');
+  console.log('💬 History:', historyLen, 'previous messages');
+  if (examplesLen > 0) console.log('📚 Doctor Examples:', examplesLen, 'examples injected');
+  console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
+
+  // Try DeepSeek first (better results), then Gemini, then fallback
+
+  // 1. Try DeepSeek first (produces better medical responses)
+  try {
+    console.log('🟣 [DEEPSEEK] Attempting DeepSeek API (primary)...');
+    const startTime = Date.now();
+    const response = await withRetry(
+      () => callDeepSeek({ topicConfig, message, provider, conversationHistory, doctorExamples }),
+      { label: 'DEEPSEEK' }
+    );
+    const duration = Date.now() - startTime;
+
+    console.log(`✅ [DEEPSEEK] Success! (${duration}ms)`);
+    console.log('📤 Response:', response.substring(0, 200) + (response.length > 200 ? '...' : ''));
+    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
+    return response;
+  } catch (deepseekError) {
+    console.error('❌ [DEEPSEEK] Failed after retries:', deepseekError.message);
+  }
+
+  // 2. Fallback to Gemini
+  try {
+    console.log('🔵 [GEMINI] Attempting Gemini 2.5 Flash API (fallback)...');
+    const startTime = Date.now();
+    const response = await withRetry(
+      () => callGemini({ topicConfig, message, provider, conversationHistory, doctorExamples }),
+      { label: 'GEMINI' }
+    );
+    const duration = Date.now() - startTime;
+
+    console.log(`✅ [GEMINI] Success! (${duration}ms)`);
+    console.log('📤 Response:', response.substring(0, 200) + (response.length > 200 ? '...' : ''));
+    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
+    return response;
+  } catch (geminiError) {
+    console.error('❌ [GEMINI] Failed after retries:', geminiError.message);
+  }
+
+  // 3. Final fallback to safe generic response
+  console.log('⚠️  [FALLBACK] Using safe generic response');
+  const fallback = generateFallbackResponse({ topicConfig, message, provider });
+  console.log('📤 Response:', fallback);
+  console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
+  return fallback;
+}
+
+module.exports = {
+  generateResponse,
+  withRetry
+};

package/functions/src/ner.js

@@ -0,0 +1,162 @@
+// Medical Named Entity Recognition Module
+//
+// CURRENT STATUS:
+// ✓ NER API integration is working and tested
+// ✓ Using dslim/bert-base-NER (general NER model) as primary model
+// ⚠️ Specialized medical NER models (OpenMed, etc.) don't have inference providers available yet
+// ✓ System gracefully degrades: NER failures don't break the safety pipeline
+// ✓ Regex-based safety checks continue to work independently
+//
+// TO USE MEDICAL-SPECIFIC NER:
+// - Wait for OpenMed or other medical NER models to become available on HF Inference API
+// - Or deploy your own inference endpoint and update MODEL_CANDIDATES
+// - Current model detects general entities (PERSON, LOCATION, ORG) which helps with PII detection
+
+const { HfInference } = require('@huggingface/inference');
+
+const HF_API_KEY = process.env.HUGGINGFACE_API_KEY;
+
+// Try multiple NER models in order of preference
+// Note: Not all models have inference providers available on HF's hosted API
+const MODEL_CANDIDATES = [
+  'dslim/bert-base-NER',  // General NER (PERSON, LOCATION, ORG) - WORKING ✓
+  'OpenMed/OpenMed-ZeroShot-NER-Pathology-Medium-209M',  // Medical NER - NO PROVIDER ✗
+  'd4data/biomedical-ner-all'  // Biomedical NER - UNKNOWN STATUS
+];
+
+// Initialize Hugging Face client (lazy loaded)
+let hfClient = null;
+
+function getHfClient() {
+  if (!hfClient && HF_API_KEY) {
+    hfClient = new HfInference(HF_API_KEY);
+  }
+  return hfClient;
+}
+
+/**
+ * Extract medical entities from text using OpenMed NER model
+ * @param {string} text - Text to analyze
+ * @returns {Promise<Array>} Array of detected entities with type and confidence
+ */
+async function extractMedicalEntities(text) {
+  const client = getHfClient();
+
+  if (!client) {
+    console.log('[NER] Hugging Face API key not configured, skipping NER');
+    return [];
+  }
+
+  if (!text || text.trim().length === 0) {
+    return [];
+  }
+
+  // Try models in order until one works
+  for (const modelName of MODEL_CANDIDATES) {
+    try {
+      console.log(`[NER] Trying model: ${modelName}...`);
+
+      const result = await client.tokenClassification({
+        model: modelName,
+        inputs: text
+      });
+
+      console.log(`[NER] ✓ Success with ${modelName}: Detected ${result.length} entities`);
+
+      return result.map(entity => ({
+        text: entity.word,
+        type: entity.entity_group || entity.entity,
+        confidence: entity.score,
+        start: entity.start,
+        end: entity.end
+      }));
+
+    } catch (error) {
+      console.warn(`[NER] ${modelName} failed: ${error.message}`);
+      // Continue to next model
+    }
+  }
+
+  // All models failed
+  console.log('[NER] All NER models failed, using regex-only detection');
+  return [];
+}
+
+/**
+ * Analyze detected entities for safety concerns
+ * @param {Array} entities - Entities from extractMedicalEntities
+ * @returns {Object} Analysis with flags and detected categories
+ */
+function analyzeEntities(entities) {
+  const analysis = {
+    hasSymptoms: false,
+    hasDiseases: false,
+    hasMedications: false,
+    hasPathology: false,
+    urgentSymptoms: [],
+    detectedTerms: []
+  };
+
+  // Urgent symptoms that should trigger escalation
+  const urgentKeywords = [
+    'chest pain', 'heart attack', 'stroke', 'seizure',
+    'bleeding', 'unconscious', 'breathing', 'suicide'
+  ];
+
+  for (const entity of entities) {
+    const text = entity.text.toLowerCase();
+    const type = entity.type.toLowerCase();
+
+    analysis.detectedTerms.push({
+      term: entity.text,
+      type: entity.type,
+      confidence: entity.confidence
+    });
+
+    // Categorize entity types
+    if (type.includes('symptom') || type.includes('sign')) {
+      analysis.hasSymptoms = true;
+    }
+    if (type.includes('disease') || type.includes('disorder')) {
+      analysis.hasDiseases = true;
+    }
+    if (type.includes('medication') || type.includes('drug')) {
+      analysis.hasMedications = true;
+    }
+    if (type.includes('pathology') || type.includes('finding')) {
+      analysis.hasPathology = true;
+    }
+
+    // Check for urgent symptoms
+    for (const urgent of urgentKeywords) {
+      if (text.includes(urgent)) {
+        analysis.urgentSymptoms.push(entity.text);
+      }
+    }
+  }
+
+  return analysis;
+}
+
+/**
+ * Enhanced safety check using NER
+ * @param {string} text - Patient message
+ * @returns {Promise<Object>} Safety analysis with NER insights
+ */
+async function analyzeMedicalSafety(text) {
+  const entities = await extractMedicalEntities(text);
+  const analysis = analyzeEntities(entities);
+
+  return {
+    entities,
+    analysis,
+    shouldEscalate: analysis.urgentSymptoms.length > 0,
+    requiresDisclaimer: analysis.hasSymptoms || analysis.hasDiseases || analysis.hasMedications
+  };
+}
+
+module.exports = {
+  extractMedicalEntities,
+  analyzeEntities,
+  analyzeMedicalSafety
+};

package/functions/src/notifications.js

@@ -0,0 +1,273 @@
+const admin = require('firebase-admin');
+
+/**
+ * Notification System Module
+ *
+ * Handles notifications for:
+ *   1. Escalations - Immediate notification when conversation is escalated
+ *   2. Unread messages - After configurable delay (default 5 min)
+ *   3. Daily digest - Summary of conversations
+ *
+ * Channels: In-app (Firestore), Email (nodemailer/future), Push (FCM/future)
+ */
+
+const NOTIFICATION_TYPES = {
+  ESCALATION: 'escalation',
+  UNREAD: 'unread_messages',
+  DAILY_DIGEST: 'daily_digest',
+  NEW_THREAD: 'new_thread',
+  DRAFT_READY: 'draft_ready'
+};
+
+/**
+ * Create an in-app notification for a doctor
+ */
+async function createNotification({ doctorId, type, title, body, threadId, metadata }) {
+  const db = admin.firestore();
+
+  const notification = {
+    doctorId,
+    type,
+    title,
+    body,
+    threadId: threadId || null,
+    metadata: metadata || {},
+    read: false,
+    createdAt: admin.firestore.FieldValue.serverTimestamp()
+  };
+
+  const ref = await db.collection('notifications').add(notification);
+  console.log(`[Notifications] Created ${type} notification for doctor ${doctorId}`);
+  return { id: ref.id, ...notification };
+}
+
+/**
+ * Notify doctor about an escalation
+ */
+async function notifyEscalation({ doctorId, threadId, patientName, reason }) {
+  const name = patientName || 'A patient';
+
+  await createNotification({
+    doctorId,
+    type: NOTIFICATION_TYPES.ESCALATION,
+    title: 'Urgent: Conversation Escalated',
+    body: `${name}'s conversation was flagged as urgent. ${reason || 'Immediate review needed.'}`,
+    threadId,
+    metadata: { reason, patientName }
+  });
+
+  // Update thread to record notification was sent
+  const db = admin.firestore();
+  await db.collection('threads').doc(threadId).update({
+    lastDoctorNotifiedAt: admin.firestore.FieldValue.serverTimestamp()
+  }).catch(err => console.error('[Notifications] Failed to update thread:', err.message));
+
+  // Future: Send email notification
+  await sendEmailNotification({
+    doctorId,
+    subject: `Urgent: ${name}'s conversation needs attention`,
+    body: `${name}'s conversation has been flagged as urgent.\n\nReason: ${reason || 'Safety concern detected'}\n\nPlease review the conversation in your EvalDoc inbox.`
+  });
+}
+
+/**
+ * Notify doctor about unread messages
+ */
+async function notifyUnread({ doctorId, unreadCount, threadIds }) {
+  await createNotification({
+    doctorId,
+    type: NOTIFICATION_TYPES.UNREAD,
+    title: `${unreadCount} Unread Message${unreadCount > 1 ? 's' : ''}`,
+    body: `You have ${unreadCount} unread patient message${unreadCount > 1 ? 's' : ''} waiting for review.`,
+    metadata: { unreadCount, threadIds }
+  });
+}
+
+/**
+ * Notify doctor that an AI draft is ready
+ */
+async function notifyDraftReady({ doctorId, threadId, patientName }) {
+  const name = patientName || 'a patient';
+
+  await createNotification({
+    doctorId,
+    type: NOTIFICATION_TYPES.DRAFT_READY,
+    title: 'AI Draft Ready for Review',
+    body: `A suggested response for ${name} is ready for your review.`,
+    threadId,
+    metadata: { patientName }
+  });
+}
+
+/**
+ * Send email notification (stub - uses nodemailer when configured)
+ */
+async function sendEmailNotification({ doctorId, subject, body }) {
+  const db = admin.firestore();
+
+  try {
+    // Get doctor's notification preferences
+    const providerDoc = await db.collection('providers').doc(doctorId).get();
+    if (!providerDoc.exists) return;
+
+    const provider = providerDoc.data();
+    const prefs = provider.notificationPreferences || {};
+
+    // Check if email notifications are enabled
+    if (prefs.emailEnabled === false) {
+      console.log(`[Notifications] Email disabled for doctor ${doctorId}`);
+      return;
+    }
+
+    const email = prefs.email || provider.email;
+    if (!email) {
+      console.log(`[Notifications] No email configured for doctor ${doctorId}`);
+      return;
+    }
+
+    // For now, log the email. In production, use nodemailer/SendGrid
+    console.log(`[Notifications] Would send email to ${email}:`);
+    console.log(`  Subject: ${subject}`);
+    console.log(`  Body: ${body.substring(0, 100)}...`);
+
+    // Future: Actual email sending with nodemailer
+    // const transporter = nodemailer.createTransport({...});
+    // await transporter.sendMail({ to: email, subject, text: body });
+
+  } catch (err) {
+    console.error('[Notifications] Email notification failed:', err.message);
+  }
+}
+
+/**
+ * Get unread notifications for a doctor
+ */
+async function getNotifications({ doctorId, limit = 20 }) {
+  const db = admin.firestore();
+
+  const snapshot = await db.collection('notifications')
+    .where('doctorId', '==', doctorId)
+    .orderBy('createdAt', 'desc')
+    .limit(limit)
+    .get();
+
+  return snapshot.docs.map(doc => ({ id: doc.id, ...doc.data() }));
+}
+
+/**
+ * Get unread notification count for a doctor
+ */
+async function getUnreadCount({ doctorId }) {
+  const db = admin.firestore();
+
+  const snapshot = await db.collection('notifications')
+    .where('doctorId', '==', doctorId)
+    .where('read', '==', false)
+    .get();
+
+  return snapshot.size;
+}
+
+/**
+ * Mark a notification as read
+ */
+async function markNotificationRead({ notificationId, doctorId }) {
+  const db = admin.firestore();
+  const ref = db.collection('notifications').doc(notificationId);
+  const doc = await ref.get();
+
+  if (!doc.exists || doc.data().doctorId !== doctorId) {
+    return false;
+  }
+
+  await ref.update({ read: true });
+  return true;
+}
+
+/**
+ * Mark all notifications as read for a doctor
+ */
+async function markAllNotificationsRead({ doctorId }) {
+  const db = admin.firestore();
+
+  const snapshot = await db.collection('notifications')
+    .where('doctorId', '==', doctorId)
+    .where('read', '==', false)
+    .get();
+
+  const batch = db.batch();
+  snapshot.docs.forEach(doc => {
+    batch.update(doc.ref, { read: true });
+  });
+
+  await batch.commit();
+  return snapshot.size;
+}
+
+/**
+ * Generate a daily digest for a doctor (called by cron/scheduler)
+ */
+async function generateDailyDigest({ doctorId }) {
+  const db = admin.firestore();
+
+  // Get threads with activity in the last 24 hours
+  const yesterday = new Date(Date.now() - 24 * 60 * 60 * 1000);
+
+  const threadsSnapshot = await db.collection('threads')
+    .where('doctorId', '==', doctorId)
+    .where('lastMessageAt', '>=', yesterday)
+    .orderBy('lastMessageAt', 'desc')
+    .limit(50)
+    .get();
+
+  if (threadsSnapshot.empty) return null;
+
+  const threads = threadsSnapshot.docs.map(doc => doc.data());
+
+  const urgentCount = threads.filter(t => t.triageCategory === 'urgent').length;
+  const needsReviewCount = threads.filter(t => t.triageCategory === 'needs_review').length;
+  const totalUnread = threads.reduce((sum, t) => sum + (t.unreadByDoctor || 0), 0);
+
+  const digestBody = [
+    `Daily Summary:`,
+    `- ${threads.length} active conversation${threads.length > 1 ? 's' : ''} in the last 24 hours`,
+    urgentCount > 0 ? `- ${urgentCount} urgent conversation${urgentCount > 1 ? 's' : ''} need attention` : null,
+    needsReviewCount > 0 ? `- ${needsReviewCount} conversation${needsReviewCount > 1 ? 's' : ''} need review` : null,
+    totalUnread > 0 ? `- ${totalUnread} total unread message${totalUnread > 1 ? 's' : ''}` : null
+  ].filter(Boolean).join('\n');
+
+  await createNotification({
+    doctorId,
+    type: NOTIFICATION_TYPES.DAILY_DIGEST,
+    title: 'Daily Conversation Digest',
+    body: digestBody,
+    metadata: {
+      activeThreads: threads.length,
+      urgentCount,
+      needsReviewCount,
+      totalUnread
+    }
+  });
+
+  // Also send email digest
+  await sendEmailNotification({
+    doctorId,
+    subject: 'EvalDoc Daily Digest',
+    body: digestBody
+  });
+
+  return { activeThreads: threads.length, urgentCount, needsReviewCount, totalUnread };
+}
+
+module.exports = {
+  NOTIFICATION_TYPES,
+  createNotification,
+  notifyEscalation,
+  notifyUnread,
+  notifyDraftReady,
+  getNotifications,
+  getUnreadCount,
+  markNotificationRead,
+  markAllNotificationsRead,
+  generateDailyDigest
+};