Refactor report generation to focus solely on medical data. Introduce MedicalReport interface, streamlining report content by removing unnecessary technical details. Consolidate endpoints to return only JSON format for reports, enhancing clarity and usability. Update report generation logic to align with new structure, ensuring compatibility with existing ComprehensiveReport interface for backward compatibility.

src/routes/report.route.ts

@@ -47,12 +47,8 @@ export async function reportRoutes(
       const existingReport = await reportService.getReport(session_id);
       if (existingReport && existingReport.report_type === reportType) {
         logger.info(`Returning existing ${reportType} report for session ${session_id}`);
-        return reply.status(200).send({
-          session_id,
-          report_type: existingReport.report_type,
-          generated_at: new Date().toISOString(),
-          report: existingReport
-        });
+        // Chỉ trả về JSON (report_content là MedicalReport)
+        return reply.status(200).send(existingReport.report_content);
       }
 
       // Generate new report
@@ -63,12 +59,8 @@ export async function reportRoutes(
         reportType
       );
 
-      return reply.status(200).send({
-        session_id,
-        report_type: report.report_type,
-        generated_at: new Date().toISOString(),
-        report
-      });
+      // Chỉ trả về JSON (report_content là MedicalReport)
+      return reply.status(200).send(report.report_content);
     } catch (error) {
       logger.error({ error }, 'Error generating report');
       return reply.status(500).send({
@@ -78,86 +70,8 @@ export async function reportRoutes(
     }
   });
 
-  // Get report markdown only (for easy display)
-  fastify.get('/api/reports/:session_id/markdown', async (
-    request: FastifyRequest<{
-      Params: { session_id: string };
-    }>,
-    reply: FastifyReply
-  ) => {
-    try {
-      const { session_id } = request.params;
-
-      const report = await reportService.getReport(session_id);
-      if (!report) {
-        // Generate if doesn't exist
-        const { data: sessionData } = await supabaseService.getClient()
-          .from('conversation_sessions')
-          .select('user_id')
-          .eq('id', session_id)
-          .single();
-
-        if (!sessionData) {
-          return reply.status(404).send({
-            error: 'Session not found'
-          });
-        }
-
-        const newReport = await reportService.generateReport(session_id, sessionData.user_id);
-        return reply.status(200).send({
-          markdown: newReport.report_markdown
-        });
-      }
-
-      return reply.status(200).send({
-        markdown: report.report_markdown
-      });
-    } catch (error) {
-      logger.error({ error }, 'Error getting report markdown');
-      return reply.status(500).send({
-        error: 'Internal server error',
-        message: 'Failed to get report markdown'
-      });
-    }
-  });
-
-  // Get report JSON only
-  fastify.get('/api/reports/:session_id/json', async (
-    request: FastifyRequest<{
-      Params: { session_id: string };
-    }>,
-    reply: FastifyReply
-  ) => {
-    try {
-      const { session_id } = request.params;
-
-      const report = await reportService.getReport(session_id);
-      if (!report) {
-        const { data: sessionData } = await supabaseService.getClient()
-          .from('conversation_sessions')
-          .select('user_id')
-          .eq('id', session_id)
-          .single();
-
-        if (!sessionData) {
-          return reply.status(404).send({
-            error: 'Session not found'
-          });
-        }
-
-        const newReport = await reportService.generateReport(session_id, sessionData.user_id);
-        return reply.status(200).send(newReport.report_content);
-      }
-
-      return reply.status(200).send(report.report_content);
-    } catch (error) {
-      logger.error({ error }, 'Error getting report JSON');
-      return reply.status(500).send({
-        error: 'Internal server error',
-        message: 'Failed to get report JSON'
-      });
-    }
-  });
+  // Chỉ có 1 endpoint duy nhất trả về JSON (MedicalReport)
+  // Đã được xử lý ở endpoint chính ở trên
 
   logger.info('Report routes registered');
 }

src/services/report-generation.service.ts

@@ -5,55 +5,86 @@ import { ToolExecutionTrackerService } from './tool-execution-tracker.service.js
 import { GeminiLLM } from '../agent/gemini-llm.js';
 import { v4 as uuidv4 } from 'uuid';
 
-export interface ComprehensiveReport {
+/**
+ * Medical Report - Chỉ chứa dữ liệu có ý nghĩa về mặt y tế
+ * Loại bỏ tất cả thông tin kỹ thuật (tool_name, execution_order, execution_time_ms, status, etc.)
+ */
+export interface MedicalReport {
   session_id: string;
   user_id: string;
-  report_type: 'full' | 'summary' | 'tools_only';
-  report_content: {
-    session_info: {
-      session_id: string;
-      created_at: string;
-      updated_at: string;
-      message_count: number;
-    };
-    conversation_timeline: Array<{
-      message_id: string;
-      role: 'user' | 'assistant';
-      content: string;
-      image_url?: string;
-      timestamp: string;
-      triage_result?: any;
+  created_at: string;
+  updated_at: string;
+  
+  // Thông tin triệu chứng và mối quan tâm
+  concerns: Array<{
+    description: string;
+    timestamp: string;
+    has_image: boolean;
+  }>;
+  
+  // Kết quả phân tích hình ảnh (nếu có)
+  image_analysis?: {
+    top_conditions: Array<{
+      condition_name: string;
+      confidence_percent: string;
+      probability: number;
     }>;
-    tool_executions: Array<{
-      tool_name: string;
-      tool_display_name: string;
-      execution_order: number;
-      input_data: any;
-      output_data: any;
-      execution_time_ms: number;
-      status: string;
-    }>;
-    summary: {
-      main_concerns: string[];
-      top_conditions_suggested: Array<{
-        name: string;
-        source: string;
-        confidence: string;
-        occurrences: number;
-      }>;
-      triage_levels_identified: Array<{
-        level: string;
-        count: number;
-      }>;
-      hospitals_suggested: Array<{
-        name: string;
-        distance_km: number;
-        address: string;
-      }>;
-      key_guidelines_retrieved: number;
-    };
+    model_type: string;
   };
-  report_markdown: string;
+  
+  // Phân loại mức độ khẩn cấp
+  triage_assessment: Array<{
+    level: 'emergency' | 'urgent' | 'routine' | 'self-care';
+    timestamp: string;
+    red_flags: string[];
+    reasoning: string;
+  }>;
+  
+  // Bệnh nghi ngờ
+  suspected_conditions: Array<{
+    condition_name: string;
+    source: 'cv_model' | 'guideline' | 'user_report' | 'reasoning';
+    confidence: 'high' | 'medium' | 'low';
+    occurrences: number;
+  }>;
+  
+  // Hướng dẫn y tế đã truy xuất
+  medical_guidelines: Array<{
+    content: string;
+    relevance_score?: number;
+    source?: string;
+  }>;
+  
+  // Khuyến nghị điều trị
+  recommendations: Array<{
+    action: string;
+    timeframe: string;
+    home_care_advice?: string;
+    warning_signs?: string;
+    timestamp: string;
+  }>;
+  
+  // Bệnh viện được đề xuất
+  suggested_hospitals: Array<{
+    name: string;
+    distance_km: number;
+    address: string;
+    rating?: number;
+    specialty_match?: 'high' | 'medium' | 'low';
+    condition?: string;
+  }>;
+}
+
+/**
+ * ComprehensiveReport - Giữ lại để backward compatibility
+ * Nhưng report_content sẽ là MedicalReport (chỉ JSON, không có markdown)
+ */
+export interface ComprehensiveReport {
+  session_id: string;
+  user_id: string;
+  report_type: 'full' | 'summary' | 'tools_only';
+  report_content: MedicalReport;
+  report_markdown?: string; // Optional, chỉ dùng cho display
 }
 
 export class ReportGenerationService {
@@ -101,7 +132,7 @@ export class ReportGenerationService {
       // Get all tool executions for this session
       const toolExecutions = await this.toolTracker.getToolExecutionsForSession(sessionId);
 
-      // Build report content
+      // Build report content (chỉ JSON, tập trung vào dữ liệu y tế)
       const reportContent = await this.buildReportContent(
         sessionData,
         conversationHistory,
@@ -109,15 +140,12 @@ export class ReportGenerationService {
         reportType
       );
 
-      // Generate markdown report using LLM
-      const reportMarkdown = await this.generateMarkdownReport(reportContent, reportType);
-
       const report: ComprehensiveReport = {
         session_id: sessionId,
         user_id: userId,
         report_type: reportType,
-        report_content: reportContent,
-        report_markdown: reportMarkdown
+        report_content: reportContent
+        // report_markdown không cần thiết nữa - chỉ dùng JSON
       };
 
       // Save report to database
@@ -132,114 +160,219 @@ export class ReportGenerationService {
   }
 
   /**
-   * Build structured report content
+   * Build structured report content - Chỉ chứa dữ liệu y tế có ý nghĩa
    */
   private async buildReportContent(
     sessionData: any,
     conversationHistory: any[],
     toolExecutions: any[],
     _reportType: string
-  ): Promise<ComprehensiveReport['report_content']> {
-    // Extract summary data
-    const mainConcerns: string[] = [];
-    const conditionsMap = new Map<string, { source: string; confidence: string; count: number }>();
-    const triageLevelsMap = new Map<string, number>();
-    const hospitals: Array<{ name: string; distance_km: number; address: string }> = [];
-    let guidelinesCount = 0;
-
-    // Process conversation history
+  ): Promise<MedicalReport> {
+    // Extract medical data từ conversation history
+    const concerns: MedicalReport['concerns'] = [];
+    const triageAssessments: MedicalReport['triage_assessment'] = [];
+    const recommendations: MedicalReport['recommendations'] = [];
+    
+    // Extract conditions và hospitals từ conversation
+    const conditionsMap = new Map<string, { 
+      source: 'cv_model' | 'guideline' | 'user_report' | 'reasoning';
+      confidence: 'high' | 'medium' | 'low';
+      count: number;
+    }>();
+    const hospitalsMap = new Map<string, MedicalReport['suggested_hospitals'][0]>();
+    
+    // Process conversation history để extract dữ liệu y tế
     conversationHistory.forEach(msg => {
+      // Extract concerns từ user messages
       if (msg.role === 'user') {
-        mainConcerns.push(msg.content);
+        concerns.push({
+          description: msg.content,
+          timestamp: msg.created_at,
+          has_image: !!msg.image_url
+        });
       }
-
+      
+      // Extract triage assessment và recommendations từ triage_result
       if (msg.triage_result) {
-        const triageLevel = msg.triage_result.triage_level;
-        triageLevelsMap.set(triageLevel, (triageLevelsMap.get(triageLevel) || 0) + 1);
-
+        const triageResult = msg.triage_result;
+        
+        // Triage assessment
+        triageAssessments.push({
+          level: triageResult.triage_level,
+          timestamp: msg.created_at,
+          red_flags: triageResult.red_flags || [],
+          reasoning: triageResult.symptom_summary || 'Đánh giá dựa trên triệu chứng và phân tích hình ảnh'
+        });
+        
+        // Recommendations
+        if (triageResult.recommendation) {
+          recommendations.push({
+            action: triageResult.recommendation.action || '',
+            timeframe: triageResult.recommendation.timeframe || '',
+            home_care_advice: triageResult.recommendation.home_care_advice,
+            warning_signs: triageResult.recommendation.warning_signs,
+            timestamp: msg.created_at
+          });
+        }
+        
         // Extract suspected conditions
-        if (msg.triage_result.suspected_conditions) {
-          msg.triage_result.suspected_conditions.forEach((cond: any) => {
+        if (triageResult.suspected_conditions) {
+          triageResult.suspected_conditions.forEach((cond: any) => {
             const key = cond.name;
+            const confidence = this.mapConfidenceToLevel(cond.confidence);
+            const source = cond.source as 'cv_model' | 'guideline' | 'user_report' | 'reasoning';
+            
             if (conditionsMap.has(key)) {
               conditionsMap.get(key)!.count++;
             } else {
               conditionsMap.set(key, {
-                source: cond.source,
-                confidence: cond.confidence,
+                source,
+                confidence,
                 count: 1
               });
             }
           });
         }
-
+        
         // Extract hospital info
-        if (msg.triage_result.nearest_clinic) {
-          hospitals.push({
-            name: msg.triage_result.nearest_clinic.name,
-            distance_km: msg.triage_result.nearest_clinic.distance_km,
-            address: msg.triage_result.nearest_clinic.address
-          });
+        if (triageResult.nearest_clinic) {
+          const clinic = triageResult.nearest_clinic;
+          const hospitalKey = clinic.name;
+          if (!hospitalsMap.has(hospitalKey)) {
+            hospitalsMap.set(hospitalKey, {
+              name: clinic.name,
+              distance_km: clinic.distance_km,
+              address: clinic.address,
+              rating: clinic.rating,
+              specialty_match: clinic.specialty_score 
+                ? (clinic.specialty_score > 0.5 ? 'high' : clinic.specialty_score > 0 ? 'medium' : 'low')
+                : undefined,
+              condition: triageResult.suspected_conditions?.[0]?.name
+            });
+          }
         }
       }
     });
-
-    // Process tool executions
+    
+    // Extract medical data từ tool executions
+    let imageAnalysis: MedicalReport['image_analysis'] | undefined;
+    const medicalGuidelines: MedicalReport['medical_guidelines'] = [];
+    
     toolExecutions.forEach(exec => {
+      // Extract CV/Image Analysis results
+      if (exec.tool_name === 'derm_cv' || exec.tool_name === 'eye_cv' || exec.tool_name === 'wound_cv') {
+        if (exec.output_data?.top_conditions && exec.output_data.top_conditions.length > 0) {
+          imageAnalysis = {
+            top_conditions: exec.output_data.top_conditions.map((cond: any) => ({
+              condition_name: cond.condition || cond.name || 'Unknown',
+              confidence_percent: cond.confidence || `${(cond.probability * 100).toFixed(1)}%`,
+              probability: cond.probability || parseFloat(cond.confidence?.replace('%', '')) / 100 || 0
+            })),
+            model_type: exec.tool_name
+          };
+        }
+      }
+      
+      // Extract RAG/Guidelines
       if (exec.tool_name === 'rag_query' || exec.tool_name === 'guideline_retrieval') {
-        if (exec.output_data?.guidelines) {
-          guidelinesCount += exec.output_data.guidelines.length;
+        if (exec.output_data?.guidelines && Array.isArray(exec.output_data.guidelines)) {
+          exec.output_data.guidelines.forEach((guideline: any) => {
+            const content = typeof guideline === 'string' 
+              ? guideline 
+              : (guideline.content || guideline.snippet || guideline.text || JSON.stringify(guideline));
+            
+            if (content && content.trim()) {
+              medicalGuidelines.push({
+                content: content.trim(),
+                relevance_score: guideline.relevance_score || guideline.score,
+                source: guideline.source || 'Bộ Y Tế'
+              });
+            }
+          });
         }
       }
-    });
-
-    return {
-      session_info: {
-        session_id: sessionData.id,
-        created_at: sessionData.created_at,
-        updated_at: sessionData.updated_at,
-        message_count: conversationHistory.length
-      },
-      conversation_timeline: conversationHistory.map(msg => ({
-        message_id: msg.id,
-        role: msg.role,
-        content: msg.content,
-        image_url: msg.image_url,
-        timestamp: msg.created_at,
-        triage_result: msg.triage_result
-      })),
-      tool_executions: toolExecutions.map(exec => ({
-        tool_name: exec.tool_name,
-        tool_display_name: exec.tool_display_name,
-        execution_order: exec.execution_order,
-        input_data: exec.input_data,
-        output_data: exec.output_data,
-        execution_time_ms: exec.execution_time_ms,
-        status: exec.status
-      })),
-      summary: {
-        main_concerns: mainConcerns,
-        top_conditions_suggested: Array.from(conditionsMap.entries())
-          .map(([name, data]) => ({
-            name,
-            source: data.source,
-            confidence: data.confidence,
-            occurrences: data.count
-          }))
-          .sort((a, b) => b.occurrences - a.occurrences),
-        triage_levels_identified: Array.from(triageLevelsMap.entries())
-          .map(([level, count]) => ({ level, count })),
-        hospitals_suggested: hospitals,
-        key_guidelines_retrieved: guidelinesCount
+      
+      // Extract hospital từ maps tool
+      if (exec.tool_name === 'maps') {
+        if (exec.output_data?.hospital) {
+          const hospital = exec.output_data.hospital;
+          const hospitalKey = hospital.name;
+          if (!hospitalsMap.has(hospitalKey)) {
+            hospitalsMap.set(hospitalKey, {
+              name: hospital.name,
+              distance_km: hospital.distance_km,
+              address: hospital.address,
+              rating: hospital.rating,
+              specialty_match: hospital.specialty_match,
+              condition: exec.input_data?.condition
+            });
+          }
+        }
+        
+        // Cũng extract từ top_hospitals nếu có
+        if (exec.output_data?.top_hospitals && Array.isArray(exec.output_data.top_hospitals)) {
+          exec.output_data.top_hospitals.forEach((hospital: any) => {
+            const hospitalKey = hospital.name;
+            if (!hospitalsMap.has(hospitalKey)) {
+              hospitalsMap.set(hospitalKey, {
+                name: hospital.name,
+                distance_km: hospital.distance_km,
+                address: hospital.address
+              });
+            }
+          });
+        }
       }
+    });
+    
+    // Build final medical report
+    const medicalReport: MedicalReport = {
+      session_id: sessionData.id,
+      user_id: sessionData.user_id || '',
+      created_at: sessionData.created_at,
+      updated_at: sessionData.updated_at,
+      concerns,
+      triage_assessment: triageAssessments,
+      suspected_conditions: Array.from(conditionsMap.entries())
+        .map(([condition_name, data]) => ({
+          condition_name,
+          source: data.source,
+          confidence: data.confidence,
+          occurrences: data.count
+        }))
+        .sort((a, b) => b.occurrences - a.occurrences),
+      medical_guidelines: medicalGuidelines,
+      recommendations,
+      suggested_hospitals: Array.from(hospitalsMap.values())
     };
+    
+    // Add image analysis nếu có
+    if (imageAnalysis) {
+      medicalReport.image_analysis = imageAnalysis;
+    }
+    
+    return medicalReport;
+  }
+  
+  /**
+   * Map confidence string to level
+   */
+  private mapConfidenceToLevel(confidence: string): 'high' | 'medium' | 'low' {
+    const confLower = confidence.toLowerCase();
+    if (confLower.includes('high') || confLower.includes('cao') || parseFloat(confLower) >= 70) {
+      return 'high';
+    }
+    if (confLower.includes('low') || confLower.includes('thấp') || parseFloat(confLower) < 40) {
+      return 'low';
+    }
+    return 'medium';
   }
 
   /**
-   * Generate markdown report using LLM
+   * Generate markdown report using LLM (Optional - chỉ dùng cho display)
    */
   private async generateMarkdownReport(
-    reportContent: ComprehensiveReport['report_content'],
+    reportContent: MedicalReport,
     reportType: string
   ): Promise<string> {
     const prompt = `Bạn là trợ lý y tế chuyên nghiệp. Hãy tạo một báo cáo tổng hợp đầy đủ về cuộc trò chuyện y tế dựa trên dữ liệu sau.
@@ -317,10 +450,10 @@ CẤU TRÚC BÁO CÁO:
   }
 
   /**
-   * Generate fallback markdown if LLM fails
+   * Generate fallback markdown if LLM fails (Optional)
    */
   private generateFallbackMarkdown(
-    reportContent: ComprehensiveReport['report_content']
+    reportContent: MedicalReport
   ): string {
     return `# BÁO CÁO TỔNG HỢP - PHIÊN TƯ VẤN Y TẾ
 
@@ -419,7 +552,7 @@ Dựa trên phân tích toàn bộ cuộc hội thoại và kết quả từ cá
           user_id: report.user_id,
           report_type: report.report_type,
           report_content: report.report_content,
-          report_markdown: report.report_markdown,
+          report_markdown: report.report_markdown || null,
           generated_at: new Date().toISOString(),
           created_at: new Date().toISOString()
         });
@@ -456,7 +589,7 @@ Dựa trên phân tích toàn bộ cuộc hội thoại và kết quả từ cá
         user_id: data.user_id,
         report_type: data.report_type,
         report_content: data.report_content,
-        report_markdown: data.report_markdown
+        report_markdown: data.report_markdown || undefined
       };
     } catch (error) {
       logger.error({ error }, 'Error getting report');