Reportation

migration_add_tool_execution.sql

@@ -0,0 +1,99 @@
+-- Migration: Add tool execution tracking and report generation support
+-- This extends the existing schema to capture full agent execution data
+
+-- Create tool_executions table to store all tool calls and results
+CREATE TABLE IF NOT EXISTS tool_executions (
+  id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+  session_id uuid REFERENCES conversation_sessions(id) ON DELETE CASCADE,
+  message_id uuid REFERENCES conversation_history(id) ON DELETE CASCADE,
+  tool_name text NOT NULL, -- 'derm_cv', 'rag_query', 'triage_rules', 'knowledge_base', 'maps'
+  tool_display_name text, -- Human-readable name
+  execution_order int NOT NULL, -- Order of execution in the workflow
+  input_data jsonb, -- Input parameters passed to tool
+  output_data jsonb, -- Full output from tool
+  execution_time_ms int, -- Duration in milliseconds
+  status text NOT NULL CHECK (status IN ('success', 'error', 'skipped')),
+  error_message text,
+  created_at timestamp with time zone DEFAULT now()
+);
+
+-- Create comprehensive_reports table for generated reports
+CREATE TABLE IF NOT EXISTS comprehensive_reports (
+  id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+  session_id uuid REFERENCES conversation_sessions(id) ON DELETE CASCADE,
+  user_id text NOT NULL,
+  report_type text NOT NULL DEFAULT 'full', -- 'full', 'summary', 'tools_only'
+  report_content jsonb NOT NULL, -- Full report structure
+  report_markdown text, -- Human-readable markdown version
+  generated_at timestamp with time zone DEFAULT now(),
+  created_at timestamp with time zone DEFAULT now()
+);
+
+-- Create indexes for faster queries
+CREATE INDEX IF NOT EXISTS idx_tool_executions_session_id ON tool_executions(session_id);
+CREATE INDEX IF NOT EXISTS idx_tool_executions_message_id ON tool_executions(message_id);
+CREATE INDEX IF NOT EXISTS idx_tool_executions_tool_name ON tool_executions(tool_name);
+CREATE INDEX IF NOT EXISTS idx_tool_executions_created_at ON tool_executions(created_at DESC);
+
+CREATE INDEX IF NOT EXISTS idx_comprehensive_reports_session_id ON comprehensive_reports(session_id);
+CREATE INDEX IF NOT EXISTS idx_comprehensive_reports_user_id ON comprehensive_reports(user_id);
+CREATE INDEX IF NOT EXISTS idx_comprehensive_reports_generated_at ON comprehensive_reports(generated_at DESC);
+
+-- Grant permissions
+GRANT ALL ON TABLE tool_executions TO service_role;
+GRANT ALL ON TABLE comprehensive_reports TO service_role;
+
+GRANT SELECT, INSERT ON TABLE tool_executions TO anon;
+GRANT SELECT, INSERT ON TABLE comprehensive_reports TO anon;
+
+-- Enable RLS
+ALTER TABLE tool_executions ENABLE ROW LEVEL SECURITY;
+ALTER TABLE comprehensive_reports ENABLE ROW LEVEL SECURITY;
+
+-- RLS Policies
+DROP POLICY IF EXISTS "Service role can access all tool executions" ON tool_executions;
+CREATE POLICY "Service role can access all tool executions"
+  ON tool_executions FOR ALL
+  TO service_role
+  USING (true)
+  WITH CHECK (true);
+
+DROP POLICY IF EXISTS "Allow anonymous access to tool executions" ON tool_executions;
+CREATE POLICY "Allow anonymous access to tool executions"
+  ON tool_executions FOR ALL
+  TO anon
+  USING (true)
+  WITH CHECK (true);
+
+DROP POLICY IF EXISTS "Users can access own tool executions" ON tool_executions;
+CREATE POLICY "Users can access own tool executions"
+  ON tool_executions FOR ALL
+  TO authenticated
+  USING (
+    EXISTS (
+      SELECT 1 FROM conversation_sessions cs
+      WHERE cs.id = tool_executions.session_id
+      AND cs.user_id = auth.uid()::text
+    )
+  );
+
+DROP POLICY IF EXISTS "Service role can access all reports" ON comprehensive_reports;
+CREATE POLICY "Service role can access all reports"
+  ON comprehensive_reports FOR ALL
+  TO service_role
+  USING (true)
+  WITH CHECK (true);
+
+DROP POLICY IF EXISTS "Allow anonymous access to reports" ON comprehensive_reports;
+CREATE POLICY "Allow anonymous access to reports"
+  ON comprehensive_reports FOR ALL
+  TO anon
+  USING (true)
+  WITH CHECK (true);
+
+DROP POLICY IF EXISTS "Users can access own reports" ON comprehensive_reports;
+CREATE POLICY "Users can access own reports"
+  ON comprehensive_reports FOR ALL
+  TO authenticated
+  USING (auth.uid()::text = user_id);
+

src/routes/index.ts

@@ -8,9 +8,12 @@ import { mapsRoutes } from './maps.route.js';
 import { sessionsRoutes } from './sessions.route.js';
 import { conversationRoutes } from './conversation.route.js';
 import { websocketRoutes } from './websocket.route.js';
+import { reportRoutes } from './report.route.js';
 import { MedagenAgent } from '../agent/agent-executor.js';
 import { SupabaseService } from '../services/supabase.service.js';
 import { MapsService } from '../services/maps.service.js';
+import { ConversationHistoryService } from '../services/conversation-history.service.js';
+import { ToolExecutionTrackerService } from '../services/tool-execution-tracker.service.js';
 
 export async function registerRoutes(
   fastify: FastifyInstance,
@@ -24,6 +27,10 @@ export async function registerRoutes(
   // Register WebSocket routes
   await websocketRoutes(fastify);
 
+  // Initialize services
+  const conversationService = new ConversationHistoryService(supabaseService.getClient());
+  const toolTracker = new ToolExecutionTrackerService(supabaseService.getClient());
+
   // Register triage routes
   await triageRoutes(fastify, agent, supabaseService, mapsService);
 
@@ -42,5 +49,8 @@ export async function registerRoutes(
   // Register sessions routes
   await sessionsRoutes(fastify, supabaseService);
   await conversationRoutes(fastify, supabaseService);
+  
+  // Register report routes
+  await reportRoutes(fastify, supabaseService, conversationService, toolTracker);
 }
 

src/routes/report.route.ts

@@ -0,0 +1,164 @@
+import { FastifyInstance, FastifyRequest, FastifyReply } from 'fastify';
+import { logger } from '../utils/logger.js';
+import { ReportGenerationService } from '../services/report-generation.service.js';
+import { ConversationHistoryService } from '../services/conversation-history.service.js';
+import { ToolExecutionTrackerService } from '../services/tool-execution-tracker.service.js';
+import { SupabaseService } from '../services/supabase.service.js';
+
+export async function reportRoutes(
+  fastify: FastifyInstance,
+  supabaseService: SupabaseService,
+  conversationService: ConversationHistoryService,
+  toolTracker: ToolExecutionTrackerService
+) {
+  const reportService = new ReportGenerationService(
+    supabaseService.getClient(),
+    conversationService,
+    toolTracker
+  );
+
+  // Generate comprehensive report for a session
+  fastify.get('/api/reports/:session_id', async (
+    request: FastifyRequest<{
+      Params: { session_id: string };
+      Querystring: { type?: 'full' | 'summary' | 'tools_only' };
+    }>,
+    reply: FastifyReply
+  ) => {
+    try {
+      const { session_id } = request.params;
+      const reportType = request.query.type || 'full';
+
+      // Get session to verify ownership (optional - add auth later)
+      const { data: sessionData, error: sessionError } = await supabaseService.getClient()
+        .from('conversation_sessions')
+        .select('user_id')
+        .eq('id', session_id)
+        .single();
+
+      if (sessionError || !sessionData) {
+        return reply.status(404).send({
+          error: 'Session not found',
+          message: `Session ${session_id} does not exist`
+        });
+      }
+
+      // Check if report already exists
+      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
+        });
+      }
+
+      // Generate new report
+      logger.info(`Generating ${reportType} report for session ${session_id}`);
+      const report = await reportService.generateReport(
+        session_id,
+        sessionData.user_id,
+        reportType
+      );
+
+      return reply.status(200).send({
+        session_id,
+        report_type: report.report_type,
+        generated_at: new Date().toISOString(),
+        report
+      });
+    } catch (error) {
+      logger.error({ error }, 'Error generating report');
+      return reply.status(500).send({
+        error: 'Internal server error',
+        message: 'Failed to generate report'
+      });
+    }
+  });
+
+  // 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'
+      });
+    }
+  });
+
+  logger.info('Report routes registered');
+}
+

src/routes/triage.route.ts

@@ -4,6 +4,8 @@ import { MedagenAgent } from '../agent/agent-executor.js';
 import { SupabaseService } from '../services/supabase.service.js';
 import { MapsService } from '../services/maps.service.js';
 import { ConversationHistoryService } from '../services/conversation-history.service.js';
+import { ToolExecutionTrackerService } from '../services/tool-execution-tracker.service.js';
+import { ToolTrackingHelper } from '../utils/tool-tracking-helper.js';
 import { logger } from '../utils/logger.js';
 import type { HealthCheckRequest, HealthCheckResponse } from '../types/index.js';
 
@@ -44,8 +46,9 @@ export async function triageRoutes(
   supabaseService: SupabaseService,
   mapsService: MapsService
 ) {
-  // Initialize conversation history service
+  // Initialize conversation history service and tool tracker
   const conversationService = new ConversationHistoryService(supabaseService.getClient());
+  const toolTracker = new ToolExecutionTrackerService(supabaseService.getClient());
   fastify.post('/api/health-check', {
     schema: {
       description: 'Endpoint chính để xử lý triage y tế. Sử dụng ReAct Agent với Gemini 2.5Flash để phân tích triệu chứng và đưa ra khuyến nghị. Hỗ trợ conversation history để xử lý multi-turn conversations.',
@@ -225,7 +228,11 @@ export async function triageRoutes(
       const conversationContext = await conversationService.getContextString(activeSessionId, 5);
 
       // Add user message to history
-      await conversationService.addUserMessage(activeSessionId, user_id, normalizedText, normalizedImageUrl);
+      const userMessage = await conversationService.addUserMessage(activeSessionId, user_id, normalizedText, normalizedImageUrl);
+
+      // Start tracking tool executions for this message
+      toolTracker.startTracking(userMessage.id);
+      const startTime = Date.now();
 
       // Process triage with agent (pass conversation context and location)
       const triageResult = await agent.processTriage(
@@ -236,21 +243,76 @@ export async function triageRoutes(
         location // Pass location for hospital finding
       );
 
+      const totalExecutionTime = Date.now() - startTime;
+
       // Add assistant response to conversation history
+      let assistantMessageId: string | undefined;
       try {
         // Use markdown message if available, otherwise fallback to recommendation.action
         const assistantMessage = (triageResult as any).message || triageResult.recommendation.action;
-        await conversationService.addAssistantMessage(
+        const assistantMessageObj = await conversationService.addAssistantMessage(
           activeSessionId,
           user_id,
           assistantMessage,
           triageResult
         );
+        assistantMessageId = assistantMessageObj.id;
       } catch (error) {
         logger.error({ error }, 'Failed to save conversation history');
         // Continue even if saving fails
       }
 
+      // Track tool executions (non-blocking)
+      try {
+        // Track CV execution if applicable
+        await ToolTrackingHelper.trackCVExecution(
+          toolTracker,
+          activeSessionId,
+          userMessage.id,
+          triageResult,
+          Math.floor(totalExecutionTime * 0.3) // Estimate 30% of time for CV
+        );
+
+        // Track Triage Rules execution
+        await ToolTrackingHelper.trackTriageRulesExecution(
+          toolTracker,
+          activeSessionId,
+          userMessage.id,
+          triageResult,
+          normalizedText || 'Image analysis',
+          Math.floor(totalExecutionTime * 0.2) // Estimate 20% of time
+        );
+
+        // Track RAG execution (estimate guidelines count from triage result)
+        const guidelinesCount = (triageResult as any).guidelines_count || 3; // Default estimate
+        await ToolTrackingHelper.trackRAGExecution(
+          toolTracker,
+          activeSessionId,
+          userMessage.id,
+          triageResult,
+          normalizedText || 'Image analysis',
+          Math.floor(totalExecutionTime * 0.3), // Estimate 30% of time
+          guidelinesCount
+        );
+
+        // Track Maps execution if hospital was found
+        const nearestClinic = (triageResult as any).nearest_clinic;
+        if (nearestClinic) {
+          const condition = triageResult.suspected_conditions?.[0]?.name;
+          await ToolTrackingHelper.trackMapsExecution(
+            toolTracker,
+            activeSessionId,
+            userMessage.id,
+            nearestClinic,
+            condition,
+            Math.floor(totalExecutionTime * 0.2) // Estimate 20% of time
+          );
+        }
+      } catch (error) {
+        logger.error({ error }, 'Failed to track tool executions');
+        // Continue even if tracking fails
+      }
+
       // Save session to database (for backward compatibility)
       try {
         await supabaseService.saveSession({

src/services/report-generation.service.ts

@@ -0,0 +1,467 @@
+import { SupabaseClient } from '@supabase/supabase-js';
+import { logger } from '../utils/logger.js';
+import { ConversationHistoryService } from './conversation-history.service.js';
+import { ToolExecutionTrackerService } from './tool-execution-tracker.service.js';
+import { GeminiLLM } from '../agent/gemini-llm.js';
+import { v4 as uuidv4 } from 'uuid';
+
+export interface ComprehensiveReport {
+  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;
+    }>;
+    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;
+    };
+  };
+  report_markdown: string;
+}
+
+export class ReportGenerationService {
+  private supabaseClient: SupabaseClient;
+  private conversationService: ConversationHistoryService;
+  private toolTracker: ToolExecutionTrackerService;
+  private llm: GeminiLLM;
+
+  constructor(
+    supabaseClient: SupabaseClient,
+    conversationService: ConversationHistoryService,
+    toolTracker: ToolExecutionTrackerService
+  ) {
+    this.supabaseClient = supabaseClient;
+    this.conversationService = conversationService;
+    this.toolTracker = toolTracker;
+    this.llm = new GeminiLLM();
+  }
+
+  /**
+   * Generate comprehensive report for a session
+   */
+  async generateReport(
+    sessionId: string,
+    userId: string,
+    reportType: 'full' | 'summary' | 'tools_only' = 'full'
+  ): Promise<ComprehensiveReport> {
+    try {
+      logger.info(`Generating ${reportType} report for session ${sessionId}`);
+
+      // Get session info
+      const { data: sessionData, error: sessionError } = await this.supabaseClient
+        .from('conversation_sessions')
+        .select('*')
+        .eq('id', sessionId)
+        .single();
+
+      if (sessionError || !sessionData) {
+        throw new Error(`Session not found: ${sessionId}`);
+      }
+
+      // Get conversation history
+      const conversationHistory = await this.conversationService.getHistory(sessionId, 1000);
+      
+      // Get all tool executions for this session
+      const toolExecutions = await this.toolTracker.getToolExecutionsForSession(sessionId);
+
+      // Build report content
+      const reportContent = await this.buildReportContent(
+        sessionData,
+        conversationHistory,
+        toolExecutions,
+        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
+      };
+
+      // Save report to database
+      await this.saveReport(report);
+
+      logger.info(`Report generated successfully for session ${sessionId}`);
+      return report;
+    } catch (error) {
+      logger.error({ error }, 'Error generating report');
+      throw error;
+    }
+  }
+
+  /**
+   * Build structured report content
+   */
+  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
+    conversationHistory.forEach(msg => {
+      if (msg.role === 'user') {
+        mainConcerns.push(msg.content);
+      }
+
+      if (msg.triage_result) {
+        const triageLevel = msg.triage_result.triage_level;
+        triageLevelsMap.set(triageLevel, (triageLevelsMap.get(triageLevel) || 0) + 1);
+
+        // Extract suspected conditions
+        if (msg.triage_result.suspected_conditions) {
+          msg.triage_result.suspected_conditions.forEach((cond: any) => {
+            const key = cond.name;
+            if (conditionsMap.has(key)) {
+              conditionsMap.get(key)!.count++;
+            } else {
+              conditionsMap.set(key, {
+                source: cond.source,
+                confidence: cond.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
+          });
+        }
+      }
+    });
+
+    // Process tool executions
+    toolExecutions.forEach(exec => {
+      if (exec.tool_name === 'rag_query' || exec.tool_name === 'guideline_retrieval') {
+        if (exec.output_data?.guidelines) {
+          guidelinesCount += exec.output_data.guidelines.length;
+        }
+      }
+    });
+
+    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
+      }
+    };
+  }
+
+  /**
+   * Generate markdown report using LLM
+   */
+  private async generateMarkdownReport(
+    reportContent: ComprehensiveReport['report_content'],
+    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.
+
+LOẠI BÁO CÁO: ${reportType === 'full' ? 'Báo cáo đầy đủ' : reportType === 'summary' ? 'Tóm tắt' : 'Chỉ công cụ'}
+
+THÔNG TIN PHIÊN:
+- Session ID: ${reportContent.session_info.session_id}
+- Thời gian bắt đầu: ${reportContent.session_info.created_at}
+- Thời gian cập nhật: ${reportContent.session_info.updated_at}
+- Số lượng tin nhắn: ${reportContent.session_info.message_count}
+
+LỊCH SỬ HỘI THOẠI:
+${reportContent.conversation_timeline.map((msg, idx) => `
+${idx + 1}. [${msg.role === 'user' ? 'Người dùng' : 'Hệ thống'}] (${msg.timestamp})
+   ${msg.role === 'user' ? 'Câu hỏi/Triệu chứng:' : 'Phản hồi:'}
+   ${msg.content}
+   ${msg.image_url ? '📷 [Có hình ảnh đính kèm]' : ''}
+   ${msg.triage_result ? `\n   Mức độ khẩn cấp: ${msg.triage_result.triage_level}` : ''}
+`).join('\n')}
+
+THỰC THI CÔNG CỤ (TOOL EXECUTIONS):
+${reportContent.tool_executions.map((exec, idx) => `
+${idx + 1}. ${exec.tool_display_name || exec.tool_name}
+   - Thứ tự: ${exec.execution_order}
+   - Trạng thái: ${exec.status}
+   - Thời gian: ${exec.execution_time_ms}ms
+   - Input: ${JSON.stringify(exec.input_data, null, 2)}
+   - Output: ${JSON.stringify(exec.output_data, null, 2)}
+`).join('\n')}
+
+TÓM TẮT:
+- Mối quan tâm chính: ${reportContent.summary.main_concerns.join(', ')}
+- Các bệnh được đề xuất: ${reportContent.summary.top_conditions_suggested.map(c => `${c.name} (${c.confidence}, xuất hiện ${c.occurrences} lần)`).join(', ')}
+- Mức độ khẩn cấp: ${reportContent.summary.triage_levels_identified.map(t => `${t.level} (${t.count} lần)`).join(', ')}
+- Bệnh viện được đề xuất: ${reportContent.summary.hospitals_suggested.map(h => `${h.name} (${h.distance_km}km)`).join(', ') || 'Không có'}
+- Số guideline đã truy xuất: ${reportContent.summary.key_guidelines_retrieved}
+
+YÊU CẦU:
+1. Tạo báo cáo markdown CHUYÊN NGHIỆP, DỄ ĐỌC, CẤU TRÚC RÕ RÀNG
+2. Bao gồm TẤT CẢ thông tin quan trọng từ tools (CV top 3, RAG guidelines đầy đủ, triage reasoning)
+3. Sử dụng tiếng Việt hoàn toàn
+4. Format đẹp với markdown (tiêu đ���, danh sách, bảng nếu cần)
+5. Nhấn mạnh các thông tin quan trọng mà response message có thể đã bỏ qua
+6. Bao gồm disclaimer y tế phù hợp
+
+CẤU TRÚC BÁO CÁO:
+# BÁO CÁO TỔNG HỢP - PHIÊN TƯ VẤN Y TẾ
+
+## 1. THÔNG TIN PHIÊN
+[Session info]
+
+## 2. TÓM TẮT CUỘC HỘI THOẠI
+[Summary of main concerns, conditions, triage levels]
+
+## 3. CHI TIẾT HỘI THOẠI
+[Full conversation timeline]
+
+## 4. PHÂN TÍCH CÔNG CỤ (TOOLS ANALYSIS)
+[Detailed tool execution results - CV top 3, RAG guidelines, etc.]
+
+## 5. KẾT LUẬN VÀ KHUYẾN NGHỊ
+[Final recommendations]
+
+**Lưu ý:** Thông tin chỉ mang tính tham khảo, không thay thế bác sĩ.`;
+
+    try {
+      const generations = await this.llm._generate([prompt]);
+      return generations.generations[0][0].text.trim();
+    } catch (error) {
+      logger.error({ error }, 'Error generating markdown report');
+      // Fallback to simple markdown
+      return this.generateFallbackMarkdown(reportContent);
+    }
+  }
+
+  /**
+   * Generate fallback markdown if LLM fails
+   */
+  private generateFallbackMarkdown(
+    reportContent: ComprehensiveReport['report_content']
+  ): string {
+    return `# BÁO CÁO TỔNG HỢP - PHIÊN TƯ VẤN Y TẾ
+
+## 1. THÔNG TIN PHIÊN
+- **Session ID:** ${reportContent.session_info.session_id}
+- **Thời gian bắt đầu:** ${reportContent.session_info.created_at}
+- **Thời gian cập nhật:** ${reportContent.session_info.updated_at}
+- **Số lượng tin nhắn:** ${reportContent.session_info.message_count}
+
+## 2. TÓM TẮT CUỘC HỘI THOẠI
+
+### Mối quan tâm chính:
+${reportContent.summary.main_concerns.map(c => `- ${c}`).join('\n')}
+
+### Các bệnh được đề xuất:
+${reportContent.summary.top_conditions_suggested.map(c => 
+  `- **${c.name}** (${c.confidence}, xuất hiện ${c.occurrences} lần, nguồn: ${c.source})`
+).join('\n')}
+
+### Mức độ khẩn cấp:
+${reportContent.summary.triage_levels_identified.map(t => 
+  `- **${t.level}**: ${t.count} lần`
+).join('\n')}
+
+### Bệnh viện được đề xuất:
+${reportContent.summary.hospitals_suggested.length > 0
+  ? reportContent.summary.hospitals_suggested.map(h => 
+      `- **${h.name}** (${h.distance_km}km) - ${h.address}`
+    ).join('\n')
+  : '- Không có bệnh viện nào được đề xuất'
+}
+
+### Số guideline đã truy xuất:
+- ${reportContent.summary.key_guidelines_retrieved} guideline snippets
+
+## 3. CHI TIẾT HỘI THOẠI
+
+${reportContent.conversation_timeline.map((msg, idx) => `
+### Tin nhắn ${idx + 1} - ${msg.role === 'user' ? 'Người dùng' : 'Hệ thống'}
+
+**Thời gian:** ${msg.timestamp}
+
+**Nội dung:**
+${msg.content}
+
+${msg.image_url ? '📷 *Có hình ảnh đính kèm*' : ''}
+
+${msg.triage_result ? `
+**Kết quả phân tích:**
+- Mức độ khẩn cấp: ${msg.triage_result.triage_level}
+- Tóm tắt triệu chứng: ${msg.triage_result.symptom_summary}
+${msg.triage_result.suspected_conditions?.length > 0 ? `
+- Bệnh nghi ngờ:
+${msg.triage_result.suspected_conditions.map((c: any) => `  - ${c.name} (${c.confidence}, nguồn: ${c.source})`).join('\n')}
+` : ''}
+` : ''}
+`).join('\n')}
+
+## 4. PHÂN TÍCH CÔNG CỤ (TOOLS ANALYSIS)
+
+${reportContent.tool_executions.map((exec, idx) => `
+### ${idx + 1}. ${exec.tool_display_name || exec.tool_name}
+
+**Thứ tự thực thi:** ${exec.execution_order}
+**Trạng thái:** ${exec.status}
+**Thời gian:** ${exec.execution_time_ms}ms
+
+**Input:**
+\`\`\`json
+${JSON.stringify(exec.input_data, null, 2)}
+\`\`\`
+
+**Output:**
+\`\`\`json
+${JSON.stringify(exec.output_data, null, 2)}
+\`\`\`
+`).join('\n')}
+
+## 5. KẾT LUẬN VÀ KHUYẾN NGHỊ
+
+Dựa trên phân tích toàn bộ cuộc hội thoại và kết quả từ các công cụ, đây là báo cáo tổng hợp đầy đủ về phiên tư vấn y tế.
+
+**Lưu ý quan trọng:** Thông tin trong báo cáo này chỉ mang tính tham khảo giáo dục, không thay thế việc khám và chẩn đoán của bác sĩ. Nếu bạn có triệu chứng nghiêm trọng, hãy đến cơ sở y tế ngay lập tức.`;
+  }
+
+  /**
+   * Save report to database
+   */
+  private async saveReport(report: ComprehensiveReport): Promise<void> {
+    try {
+      const { error } = await this.supabaseClient
+        .from('comprehensive_reports')
+        .insert({
+          id: uuidv4(),
+          session_id: report.session_id,
+          user_id: report.user_id,
+          report_type: report.report_type,
+          report_content: report.report_content,
+          report_markdown: report.report_markdown,
+          generated_at: new Date().toISOString(),
+          created_at: new Date().toISOString()
+        });
+
+      if (error) {
+        logger.error({ error }, 'Failed to save report');
+        throw error;
+      }
+    } catch (error) {
+      logger.error({ error }, 'Error saving report');
+      throw error;
+    }
+  }
+
+  /**
+   * Get existing report for a session
+   */
+  async getReport(sessionId: string): Promise<ComprehensiveReport | null> {
+    try {
+      const { data, error } = await this.supabaseClient
+        .from('comprehensive_reports')
+        .select('*')
+        .eq('session_id', sessionId)
+        .order('generated_at', { ascending: false })
+        .limit(1)
+        .single();
+
+      if (error || !data) {
+        return null;
+      }
+
+      return {
+        session_id: data.session_id,
+        user_id: data.user_id,
+        report_type: data.report_type,
+        report_content: data.report_content,
+        report_markdown: data.report_markdown
+      };
+    } catch (error) {
+      logger.error({ error }, 'Error getting report');
+      return null;
+    }
+  }
+}
+

src/services/tool-execution-tracker.service.ts

@@ -0,0 +1,157 @@
+import { SupabaseClient } from '@supabase/supabase-js';
+import { logger } from '../utils/logger.js';
+import { v4 as uuidv4 } from 'uuid';
+
+export interface ToolExecution {
+  tool_name: string;
+  tool_display_name: string;
+  execution_order: number;
+  input_data: any;
+  output_data: any;
+  execution_time_ms: number;
+  status: 'success' | 'error' | 'skipped';
+  error_message?: string;
+}
+
+export class ToolExecutionTrackerService {
+  private supabaseClient: SupabaseClient;
+  private currentMessageId: string | null = null;
+  private executionOrder: number = 0;
+
+  constructor(supabaseClient: SupabaseClient) {
+    this.supabaseClient = supabaseClient;
+  }
+
+  /**
+   * Start tracking for a new message
+   */
+  startTracking(messageId: string): void {
+    this.currentMessageId = messageId;
+    this.executionOrder = 0;
+  }
+
+  /**
+   * Track a tool execution
+   */
+  async trackToolExecution(
+    sessionId: string,
+    execution: ToolExecution
+  ): Promise<void> {
+    try {
+      if (!this.currentMessageId) {
+        logger.warn('No message ID set for tool execution tracking');
+        return;
+      }
+
+      const executionData = {
+        session_id: sessionId,
+        message_id: this.currentMessageId,
+        tool_name: execution.tool_name,
+        tool_display_name: execution.tool_display_name,
+        execution_order: execution.execution_order,
+        input_data: execution.input_data,
+        output_data: execution.output_data,
+        execution_time_ms: execution.execution_time_ms,
+        status: execution.status,
+        error_message: execution.error_message || null,
+        created_at: new Date().toISOString()
+      };
+
+      const { error } = await this.supabaseClient
+        .from('tool_executions')
+        .insert(executionData);
+
+      if (error) {
+        logger.error({ error }, 'Failed to track tool execution');
+        // Don't throw - tracking failure shouldn't break the workflow
+      } else {
+        logger.debug(`Tracked tool execution: ${execution.tool_name} (order: ${execution.execution_order})`);
+      }
+    } catch (error) {
+      logger.error({ error }, 'Error tracking tool execution');
+      // Don't throw - tracking is non-critical
+    }
+  }
+
+  /**
+   * Get next execution order number
+   */
+  getNextExecutionOrder(): number {
+    this.executionOrder++;
+    return this.executionOrder;
+  }
+
+  /**
+   * Get all tool executions for a message
+   */
+  async getToolExecutionsForMessage(messageId: string): Promise<ToolExecution[]> {
+    try {
+      const { data, error } = await this.supabaseClient
+        .from('tool_executions')
+        .select('*')
+        .eq('message_id', messageId)
+        .order('execution_order', { ascending: true });
+
+      if (error) {
+        logger.error({ error }, 'Failed to get tool executions');
+        return [];
+      }
+
+      return (data || []).map(row => ({
+        tool_name: row.tool_name,
+        tool_display_name: row.tool_display_name,
+        execution_order: row.execution_order,
+        input_data: row.input_data,
+        output_data: row.output_data,
+        execution_time_ms: row.execution_time_ms,
+        status: row.status,
+        error_message: row.error_message
+      }));
+    } catch (error) {
+      logger.error({ error }, 'Error getting tool executions');
+      return [];
+    }
+  }
+
+  /**
+   * Get all tool executions for a session
+   */
+  async getToolExecutionsForSession(sessionId: string): Promise<ToolExecution[]> {
+    try {
+      const { data, error } = await this.supabaseClient
+        .from('tool_executions')
+        .select('*')
+        .eq('session_id', sessionId)
+        .order('created_at', { ascending: true })
+        .order('execution_order', { ascending: true });
+
+      if (error) {
+        logger.error({ error }, 'Failed to get tool executions for session');
+        return [];
+      }
+
+      return (data || []).map(row => ({
+        tool_name: row.tool_name,
+        tool_display_name: row.tool_display_name,
+        execution_order: row.execution_order,
+        input_data: row.input_data,
+        output_data: row.output_data,
+        execution_time_ms: row.execution_time_ms,
+        status: row.status,
+        error_message: row.error_message
+      }));
+    } catch (error) {
+      logger.error({ error }, 'Error getting tool executions for session');
+      return [];
+    }
+  }
+
+  /**
+   * Reset tracking state
+   */
+  reset(): void {
+    this.currentMessageId = null;
+    this.executionOrder = 0;
+  }
+}
+

src/utils/tool-tracking-helper.ts

@@ -0,0 +1,174 @@
+import { ToolExecutionTrackerService, type ToolExecution } from '../services/tool-execution-tracker.service.js';
+import { logger } from './logger.js';
+import type { TriageResult } from '../types/index.js';
+
+/**
+ * Helper to track tool executions from agent results
+ * This extracts tool execution data from TriageResult and tracks them
+ */
+export class ToolTrackingHelper {
+  /**
+   * Track CV tool execution from triage result
+   */
+  static async trackCVExecution(
+    tracker: ToolExecutionTrackerService,
+    sessionId: string,
+    messageId: string,
+    triageResult: TriageResult,
+    executionTime: number
+  ): Promise<void> {
+    const cvFindings = triageResult.cv_findings;
+    
+    if (cvFindings.model_used === 'none' || !cvFindings.raw_output?.top_predictions) {
+      return; // No CV execution
+    }
+
+    const toolName = cvFindings.model_used;
+    const toolDisplayName = this.getToolDisplayName(toolName);
+    
+    const execution: ToolExecution = {
+      tool_name: toolName,
+      tool_display_name: toolDisplayName,
+      execution_order: tracker.getNextExecutionOrder(),
+      input_data: {
+        model: toolName,
+        has_image: true
+      },
+      output_data: {
+        top_conditions: cvFindings.raw_output.top_predictions.map((p: any) => ({
+          condition: p.condition,
+          probability: p.probability,
+          confidence: (p.probability * 100).toFixed(1) + '%'
+        })),
+        model_used: toolName
+      },
+      execution_time_ms: executionTime,
+      status: 'success'
+    };
+
+    await tracker.trackToolExecution(sessionId, execution);
+  }
+
+  /**
+   * Track RAG/Guideline retrieval execution
+   * This is inferred from triage result and suspected conditions
+   */
+  static async trackRAGExecution(
+    tracker: ToolExecutionTrackerService,
+    sessionId: string,
+    messageId: string,
+    triageResult: TriageResult,
+    userText: string,
+    executionTime: number,
+    guidelinesCount?: number
+  ): Promise<void> {
+    // RAG is always called in triage workflow
+    const execution: ToolExecution = {
+      tool_name: 'rag_query',
+      tool_display_name: 'Medical Guidelines Retrieval',
+      execution_order: tracker.getNextExecutionOrder(),
+      input_data: {
+        symptoms: userText,
+        suspected_conditions: triageResult.suspected_conditions.map(c => c.name),
+        triage_level: triageResult.triage_level
+      },
+      output_data: {
+        guidelines_retrieved: guidelinesCount || 0,
+        triage_level: triageResult.triage_level,
+        suspected_conditions: triageResult.suspected_conditions
+      },
+      execution_time_ms: executionTime,
+      status: 'success'
+    };
+
+    await tracker.trackToolExecution(sessionId, execution);
+  }
+
+  /**
+   * Track Triage Rules execution
+   */
+  static async trackTriageRulesExecution(
+    tracker: ToolExecutionTrackerService,
+    sessionId: string,
+    messageId: string,
+    triageResult: TriageResult,
+    userText: string,
+    executionTime: number
+  ): Promise<void> {
+    const execution: ToolExecution = {
+      tool_name: 'triage_rules',
+      tool_display_name: 'Triage Classification',
+      execution_order: tracker.getNextExecutionOrder(),
+      input_data: {
+        symptoms: userText,
+        has_cv_results: triageResult.cv_findings.model_used !== 'none'
+      },
+      output_data: {
+        triage_level: triageResult.triage_level,
+        red_flags: triageResult.red_flags,
+        reasoning: (triageResult as any).reasoning || 'Triage rules evaluation completed'
+      },
+      execution_time_ms: executionTime,
+      status: 'success'
+    };
+
+    await tracker.trackToolExecution(sessionId, execution);
+  }
+
+  /**
+   * Track Hospital/Maps execution
+   */
+  static async trackMapsExecution(
+    tracker: ToolExecutionTrackerService,
+    sessionId: string,
+    messageId: string,
+    nearestClinic: any,
+    condition: string | undefined,
+    executionTime: number
+  ): Promise<void> {
+    if (!nearestClinic) {
+      return; // No hospital search
+    }
+
+    const execution: ToolExecution = {
+      tool_name: 'maps',
+      tool_display_name: 'Hospital Search',
+      execution_order: tracker.getNextExecutionOrder(),
+      input_data: {
+        condition: condition,
+        location: 'user_location'
+      },
+      output_data: {
+        nearest_clinic: {
+          name: nearestClinic.name,
+          distance_km: nearestClinic.distance_km,
+          address: nearestClinic.address,
+          rating: nearestClinic.rating
+        }
+      },
+      execution_time_ms: executionTime,
+      status: 'success'
+    };
+
+    await tracker.trackToolExecution(sessionId, execution);
+  }
+
+  /**
+   * Get tool display name
+   */
+  private static getToolDisplayName(toolName: string): string {
+    const displayNames: Record<string, string> = {
+      'derm_cv': 'Dermatology CV Analysis',
+      'eye_cv': 'Eye Condition Analysis',
+      'wound_cv': 'Wound Assessment',
+      'triage_rules': 'Triage Classification',
+      'rag_query': 'Medical Guidelines Retrieval',
+      'guideline_retrieval': 'Medical Guidelines Retrieval',
+      'knowledge_base': 'Structured Knowledge Search',
+      'maps': 'Hospital Search'
+    };
+
+    return displayNames[toolName] || toolName;
+  }
+}
+

test_api_usecases.js

@@ -26,6 +26,59 @@ const useCases = [
       user_id: 'test_user_2'
     }
   },
+  {
+    id: 11,
+    name: 'MCP Hospital - Emergency case với location',
+    expectedMCP: 'HOSPITAL',
+    payload: {
+      text: 'Tôi bị đau ngực dữ dội, khó thở, đổ mồ hôi lạnh',
+      user_id: 'test_user_11',
+      location: {
+        lat: 10.762622, // Ho Chi Minh City
+        lng: 106.660172
+      }
+    }
+  },
+  {
+    id: 12,
+    name: 'MCP Hospital - Urgent case với location',
+    expectedMCP: 'HOSPITAL',
+    payload: {
+      text: 'Tôi bị sốt cao 39 độ, đau đầu dữ dội, buồn nôn',
+      user_id: 'test_user_12',
+      location: {
+        lat: 21.028511, // Hanoi
+        lng: 105.804817
+      }
+    }
+  },
+  {
+    id: 13,
+    name: 'MCP Hospital - User yêu cầu tìm bệnh viện',
+    expectedMCP: 'HOSPITAL',
+    payload: {
+      text: 'Tôi cần tìm bệnh viện gần nhất để khám',
+      user_id: 'test_user_13',
+      location: {
+        lat: 10.762622,
+        lng: 106.660172
+      }
+    }
+  },
+  {
+    id: 14,
+    name: 'MCP CV + RAG + Hospital - Da liễu emergency với location',
+    expectedMCP: 'CV+RAG+HOSPITAL',
+    payload: {
+      text: 'Da tôi bị viêm nặng, đỏ rát, có mủ',
+      image_url: 'https://www.rosacea.org/sites/default/files/images/rosacea_subtype2.jpg',
+      user_id: 'test_user_14',
+      location: {
+        lat: 10.762622,
+        lng: 106.660172
+      }
+    }
+  },
   // {
   //   id: 3,
   //   name: 'MCP CSDL - Câu hỏi định nghĩa bệnh',
@@ -155,6 +208,8 @@ async function runTests() {
       
       const hasCVContent = response.data.cv_findings?.model_used && 
                           response.data.cv_findings.model_used !== 'none';
+      
+      const hasHospitalContent = !!response.data.nearest_clinic;
 
       const result = {
         id: useCase.id,
@@ -171,7 +226,10 @@ async function runTests() {
         ragDetected: hasRAGContent,
         csdlDetected: hasCSDLContent,
         cvDetected: hasCVContent,
+        hospitalDetected: hasHospitalContent,
         cvModel: response.data.cv_findings?.model_used || 'none',
+        hospitalName: response.data.nearest_clinic?.name || null,
+        hospitalDistance: response.data.nearest_clinic?.distance_km || null,
         responseLength: JSON.stringify(response.data).length
       };
 
@@ -200,6 +258,12 @@ async function runTests() {
         if (!result.ragDetected) validations.push('Expected RAG but not detected');
       }
       
+      if (useCase.expectedMCP === 'CV+RAG+HOSPITAL') {
+        if (!result.cvDetected) validations.push('Expected CV but not detected');
+        if (!result.ragDetected) validations.push('Expected RAG but not detected');
+        if (!result.hospitalDetected) validations.push('Expected Hospital but not detected');
+      }
+      
       if (useCase.expectedMCP === 'RAG' && !result.ragDetected) {
         validations.push('Expected RAG but not detected in response');
       }
@@ -208,6 +272,10 @@ async function runTests() {
         validations.push('Expected CSDL but not detected in response');
       }
       
+      if (useCase.expectedMCP === 'HOSPITAL') {
+        if (!result.hospitalDetected) validations.push('Expected Hospital but not detected');
+      }
+      
       if (useCase.expectedMCP === 'BOTH') {
         if (!result.ragDetected && !result.csdlDetected) {
           validations.push('Expected both RAG and CSDL but neither detected');
@@ -240,6 +308,10 @@ async function runTests() {
       console.log(`   CV Detected: ${result.cvDetected ? '✅' : '❌'} (${result.cvModel})`);
       console.log(`   RAG Detected: ${result.ragDetected ? '✅' : '❌'}`);
       console.log(`   CSDL Detected: ${result.csdlDetected ? '✅' : '❌'}`);
+      console.log(`   Hospital Detected: ${result.hospitalDetected ? '✅' : '❌'}`);
+      if (result.hospitalDetected) {
+        console.log(`   Hospital: ${result.hospitalName || 'N/A'} (${result.hospitalDistance ? result.hospitalDistance + 'km' : 'N/A'})`);
+      }
       console.log(`   Triage Level: ${result.triageLevel || 'N/A'}`);
       console.log(`   Suspected Conditions: ${result.hasSuspectedConditions ? 'Yes' : 'No'}`);
       console.log(`   Response Length: ${result.responseLength} chars`);
@@ -278,18 +350,26 @@ async function runTests() {
   console.log(`❌ Failed: ${failed}`);
   console.log(`📈 Success Rate: ${((passed / useCases.length) * 100).toFixed(1)}%`);
   
-  console.log('\n--- Detailed Results ---');
+  console.log('\n--- Detailed Results (Short) ---');
   results.forEach(r => {
     const icon = r.status === 'PASS' ? '✅' : r.status === 'WARNING' ? '⚠️' : '❌';
+    const mcpUsed = [];
+    if (r.cvDetected) mcpUsed.push('CV');
+    if (r.ragDetected) mcpUsed.push('RAG');
+    if (r.csdlDetected) mcpUsed.push('CSDL');
+    if (r.hospitalDetected) mcpUsed.push('HOSPITAL');
+    
     console.log(`${icon} UC${r.id}: ${r.name}`);
     if (r.status === 'PASS' || r.status === 'WARNING') {
-      console.log(`   Expected: ${r.expectedMCP} | RAG: ${r.ragDetected ? '✅' : '❌'} | CSDL: ${r.csdlDetected ? '✅' : '❌'}`);
-      console.log(`   Triage: ${r.triageLevel} | Duration: ${r.duration} | Length: ${r.responseLength} chars`);
-      if (r.validations) {
-        console.log(`   Issues: ${r.validations.join(', ')}`);
+      console.log(`   Expected: ${r.expectedMCP} | Used: ${mcpUsed.join('+') || 'None'} | Triage: ${r.triageLevel}`);
+      if (r.hospitalDetected) {
+        console.log(`   🏥 Hospital: ${r.hospitalName} (${r.hospitalDistance}km)`);
+      }
+      if (r.validations && r.validations.length > 0) {
+        console.log(`   ⚠️  ${r.validations.join(', ')}`);
       }
     } else {
-      console.log(`   Error: ${r.error}`);
+      console.log(`   ❌ Error: ${r.error}`);
     }
   });
 
@@ -308,25 +388,36 @@ async function runTests() {
   console.log('\n--- MCP Usage Statistics ---');
   let ragCount = 0;
   let csdlCount = 0;
+  let cvCount = 0;
+  let hospitalCount = 0;
   let bothCount = 0;
+  let allThreeCount = 0;
   let noneCount = 0;
   
   results.forEach(r => {
-    if (r.ragDetected && r.csdlDetected) {
-      bothCount++;
-    } else if (r.ragDetected) {
-      ragCount++;
-    } else if (r.csdlDetected) {
-      csdlCount++;
-    } else {
-      noneCount++;
+    if (r.status === 'PASS' || r.status === 'WARNING') {
+      if (r.ragDetected) ragCount++;
+      if (r.csdlDetected) csdlCount++;
+      if (r.cvDetected) cvCount++;
+      if (r.hospitalDetected) hospitalCount++;
+      
+      if (r.ragDetected && r.csdlDetected && r.hospitalDetected) {
+        allThreeCount++;
+      } else if (r.ragDetected && r.csdlDetected) {
+        bothCount++;
+      } else if (!r.ragDetected && !r.csdlDetected && !r.cvDetected && !r.hospitalDetected) {
+        noneCount++;
+      }
     }
   });
   
-  console.log(`   RAG Only: ${ragCount}`);
-  console.log(`   CSDL Only: ${csdlCount}`);
-  console.log(`   Both RAG + CSDL: ${bothCount}`);
-  console.log(`   Neither: ${noneCount}`);
+  console.log(`   CV: ${cvCount}`);
+  console.log(`   RAG: ${ragCount}`);
+  console.log(`   CSDL: ${csdlCount}`);
+  console.log(`   Hospital: ${hospitalCount}`);
+  console.log(`   RAG + CSDL: ${bothCount}`);
+  console.log(`   RAG + CSDL + Hospital: ${allThreeCount}`);
+  console.log(`   None: ${noneCount}`);
 
   console.log('\n--- Expected vs Actual MCP Usage ---');
   const mcpStats = {};