fix bug

src/agent/agent-executor.ts

@@ -38,7 +38,7 @@ export class MedagenAgent {
       this.initialized = true;
       logger.info('Medagen Agent initialized successfully');
     } catch (error) {
-      logger.error(`Failed to initialize agent: ${error}`);
+      logger.error({ error }, 'Failed to initialize agent');
       throw error;
     }
   }
@@ -98,7 +98,7 @@ export class MedagenAgent {
           }
       }
     } catch (error) {
-      logger.error(`Error processing query: ${error}`);
+      logger.error({ error }, 'Error processing query');
       
       // Return safe default
       return this.getSafeDefaultResponse(userText);
@@ -254,7 +254,7 @@ Tạo response JSON (ONLY JSON, no markdown):
 
       throw new Error('Failed to parse LLM response');
     } catch (error) {
-      logger.error(`Error processing disease info query: ${error}`);
+      logger.error({ error }, 'Error processing disease info query');
       return this.getSafeDefaultResponse(userText);
     }
   }
@@ -286,7 +286,7 @@ Tạo response JSON (ONLY JSON, no markdown):
 ${conversationContext ? `Context: ${conversationContext}` : ''}
 
 Thông tin từ hướng dẫn:
-${guidelines.map((g, i) => `${i + 1}. ${g.content || g.snippet || g}`).join('\n')}
+${guidelines.map((g, i) => `${i + 1}. ${g}`).join('\n')}
 
 Trả lời một cách hữu ích, giáo dục, an toàn. Nhấn mạnh không thay thế bác sĩ.
 
@@ -381,7 +381,7 @@ JSON response (ONLY JSON):
 
       return finalResult;
     } catch (error) {
-      logger.error(`Error in custom agent workflow: ${error}`);
+      logger.error({ error }, 'Error in custom agent workflow');
       throw error;
     }
   }
@@ -424,7 +424,7 @@ JSON response (ONLY JSON):
         conversationContext
       );
     } catch (error) {
-      logger.error(`Error in text-only triage: ${error}`);
+      logger.error({ error }, 'Error in text-only triage');
       throw error;
     }
   }

src/agent/gemini-embedding.ts

@@ -26,8 +26,8 @@ export class GeminiEmbedding extends Embeddings {
       
       return embeddings;
     } catch (error) {
-      logger.error('Error generating embeddings:', error);
-      throw new Error(`Embedding error: ${error}`);
+      logger.error({ error }, 'Error generating embeddings');
+      throw new Error(`Embedding error: ${error instanceof Error ? error.message : String(error)}`);
     }
   }
 
@@ -37,8 +37,8 @@ export class GeminiEmbedding extends Embeddings {
       const result = await model.embedContent(text);
       return result.embedding.values;
     } catch (error) {
-      logger.error('Error generating query embedding:', error);
-      throw new Error(`Query embedding error: ${error}`);
+      logger.error({ error }, 'Error generating query embedding');
+      throw new Error(`Query embedding error: ${error instanceof Error ? error.message : String(error)}`);
     }
   }
 }

src/agent/gemini-llm.ts

@@ -4,7 +4,6 @@ import { config } from '../utils/config.js';
 import { logger } from '../utils/logger.js';
 import type { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
 import type { LLMResult } from '@langchain/core/outputs';
-
 export class GeminiLLM extends LLM {
   private genAI: GoogleGenerativeAI;
   private modelName: string;
@@ -19,10 +18,19 @@ export class GeminiLLM extends LLM {
     return 'gemini';
   }
 
+  async _call(
+    prompt: string,
+    _options?: this['ParsedCallOptions'],
+    _runManager?: CallbackManagerForLLMRun
+  ): Promise<string> {
+    const result = await this._generate([prompt], _options, _runManager);
+    return result.generations[0][0].text;
+  }
+
   async _generate(
     prompts: string[],
-    options?: this['ParsedCallOptions'],
-    runManager?: CallbackManagerForLLMRun
+    _options?: this['ParsedCallOptions'],
+    _runManager?: CallbackManagerForLLMRun
   ): Promise<LLMResult> {
     try {
       const model = this.genAI.getGenerativeModel({ model: this.modelName });
@@ -48,8 +56,8 @@ export class GeminiLLM extends LLM {
         generations: [generations]
       };
     } catch (error) {
-      logger.error('Error calling Gemini API:', error);
-      throw new Error(`Gemini API error: ${error}`);
+      logger.error({ error }, 'Error calling Gemini API');
+      throw new Error(`Gemini API error: ${error instanceof Error ? error.message : String(error)}`);
     }
   }
 }

src/agent/websocket-callback.handler.ts

@@ -63,14 +63,14 @@ export class WebSocketStreamHandler extends BaseCallbackHandler {
       await wsConnectionManager.sendToSession(this.sessionId, actionStartMsg);
       logger.debug(`Sent action_start for tool ${toolName}, session ${this.sessionId}`);
     } catch (error) {
-      logger.error('Error in onAgentAction:', error);
+      logger.error({ error }, 'Error in onAgentAction');
     }
   }
 
   /**
    * Called when tool execution completes
    */
-  async onToolEnd(output: string, runId: string, parentRunId?: string, tags?: string[]): Promise<void> {
+  async onToolEnd(output: string, _runId: string, _parentRunId?: string, _tags?: string[]): Promise<void> {
     try {
       // Try to parse tool output as JSON (most tools return JSON)
       let results: any;
@@ -81,7 +81,7 @@ export class WebSocketStreamHandler extends BaseCallbackHandler {
       }
 
       // Get tool name from tags or use fallback
-      const toolName = tags?.find(tag => tag in TOOL_DISPLAY_NAMES) || 'unknown';
+      const toolName = _tags?.find((tag: string) => tag in TOOL_DISPLAY_NAMES) || 'unknown';
 
       // Calculate duration
       const startTime = this.actionStartTimes.get(toolName);
@@ -114,16 +114,16 @@ export class WebSocketStreamHandler extends BaseCallbackHandler {
         logger.debug(`Sent observation for tool ${toolName}, session ${this.sessionId}`);
       }
     } catch (error) {
-      logger.error('Error in onToolEnd:', error);
+      logger.error({ error }, 'Error in onToolEnd');
     }
   }
 
   /**
    * Called when tool execution fails
    */
-  async onToolError(error: Error, runId: string, parentRunId?: string, tags?: string[]): Promise<void> {
+  async onToolError(error: Error, _runId: string, _parentRunId?: string, _tags?: string[]): Promise<void> {
     try {
-      const toolName = tags?.find(tag => tag in TOOL_DISPLAY_NAMES) || 'unknown';
+      const toolName = _tags?.find((tag: string) => tag in TOOL_DISPLAY_NAMES) || 'unknown';
 
       // Calculate duration
       const startTime = this.actionStartTimes.get(toolName);
@@ -142,7 +142,7 @@ export class WebSocketStreamHandler extends BaseCallbackHandler {
       await wsConnectionManager.sendToSession(this.sessionId, actionErrorMsg);
       logger.debug(`Sent action_error for tool ${toolName}, session ${this.sessionId}`);
     } catch (err) {
-      logger.error('Error in onToolError:', err);
+      logger.error({ error: err }, 'Error in onToolError');
     }
   }
 
@@ -173,7 +173,7 @@ export class WebSocketStreamHandler extends BaseCallbackHandler {
       await wsConnectionManager.sendToSession(this.sessionId, finalAnswerMsg);
       logger.debug(`Sent final_answer for session ${this.sessionId}`);
     } catch (error) {
-      logger.error('Error in onAgentFinish:', error);
+      logger.error({ error }, 'Error in onAgentFinish');
     }
   }
 
@@ -197,9 +197,9 @@ export class WebSocketStreamHandler extends BaseCallbackHandler {
   async onChainError(error: Error): Promise<void> {
     try {
       wsConnectionManager.sendError(this.sessionId, 'CHAIN_ERROR', error.message);
-      logger.error(`Chain error for session ${this.sessionId}:`, error);
+      logger.error({ error, sessionId: this.sessionId }, 'Chain error');
     } catch (err) {
-      logger.error('Error in onChainError:', err);
+      logger.error({ error: err }, 'Error in onChainError');
     }
   }
 }

src/index.ts

@@ -36,7 +36,7 @@ async function startServer() {
     await fastify.register(websocket, {
       options: {
         maxPayload: 10 * 1024, // 10KB max message size
-        verifyClient: (info, callback) => {
+        verifyClient: (_info, callback) => {
           // Optional: Add custom verification logic here
           callback(true);
         }
@@ -44,7 +44,7 @@ async function startServer() {
     });
 
     // Register Swagger
-    await fastify.register(swagger, swaggerOptions);
+    await fastify.register(swagger as any, swaggerOptions);
     await fastify.register(swaggerUi, swaggerUiOptions);
 
     // Initialize services
@@ -62,7 +62,7 @@ async function startServer() {
     await registerRoutes(fastify, agent, supabaseService, mapsService);
 
     // Add request logging
-    fastify.addHook('onRequest', async (request, reply) => {
+    fastify.addHook('onRequest', async (request) => {
       logger.info({
         method: request.method,
         url: request.url,
@@ -75,29 +75,30 @@ async function startServer() {
       logger.info({
         method: request.method,
         url: request.url,
-        statusCode: reply.statusCode,
-        responseTime: reply.getResponseTime()
+        statusCode: reply.statusCode
       }, 'Request completed');
     });
 
     // Error handler
-    fastify.setErrorHandler((error, request, reply) => {
+    fastify.setErrorHandler((error, _request, reply) => {
       // Handle validation errors (Fastify schema validation)
-      if (error.validation) {
+      if (error && typeof error === 'object' && 'validation' in error && error.validation) {
+        const validationError = error as { validation?: unknown; message?: string };
         logger.warn({ validation: error.validation }, 'Validation error');
         return reply.status(400).send({
           error: 'Validation Error',
-          message: error.message,
+          message: validationError.message || 'Validation failed',
           details: error.validation
         });
       }
 
       // Handle other errors
-      logger.error(error, 'Unhandled error');
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      logger.error({ error }, 'Unhandled error');
       
-      reply.status(500).send({
+      return reply.status(500).send({
         error: 'Internal Server Error',
-        message: process.env.NODE_ENV === 'development' ? error.message : 'An error occurred'
+        message: process.env.NODE_ENV === 'development' ? errorMessage : 'An error occurred'
       });
     });
 
@@ -113,7 +114,7 @@ async function startServer() {
     logger.info(`🔌 WebSocket endpoint: ws://${host}:${port}/ws/chat`);
     logger.info(`📚 Swagger docs: http://${host}:${port}/docs`);
   } catch (error) {
-    logger.error(error, 'Failed to start server');
+    logger.error({ error }, 'Failed to start server');
     process.exit(1);
   }
 }

src/mcp_tools/cv-tools.ts

@@ -27,7 +27,7 @@ export function createDermCVTool(cvService: CVService): DynamicTool {
         
         return JSON.stringify({ top_predictions });
       } catch (error) {
-        logger.error('derm_cv tool error:', error);
+        logger.error({ error }, 'derm_cv tool error');
         return JSON.stringify({ error: 'Failed to analyze dermatology image', top_predictions: [] });
       }
     }
@@ -58,7 +58,7 @@ export function createEyeCVTool(cvService: CVService): DynamicTool {
         
         return JSON.stringify({ top_predictions });
       } catch (error) {
-        logger.error('eye_cv tool error:', error);
+        logger.error({ error }, 'eye_cv tool error');
         return JSON.stringify({ error: 'Failed to analyze eye image', top_predictions: [] });
       }
     }
@@ -89,7 +89,7 @@ export function createWoundCVTool(cvService: CVService): DynamicTool {
         
         return JSON.stringify({ top_predictions });
       } catch (error) {
-        logger.error('wound_cv tool error:', error);
+        logger.error({ error }, 'wound_cv tool error');
         return JSON.stringify({ error: 'Failed to analyze wound image', top_predictions: [] });
       }
     }

src/mcp_tools/rag-tool.ts

@@ -29,7 +29,7 @@ export function createGuidelineRAGTool(ragService: RAGService): DynamicTool {
           guidelines: guidelines
         });
       } catch (error) {
-        logger.error('guideline_rag tool error:', error);
+        logger.error({ error }, 'guideline_rag tool error');
         return JSON.stringify({ 
           error: 'Failed to retrieve guidelines',
           guidelines: []

src/mcp_tools/triage-tool.ts

@@ -46,7 +46,7 @@ export function createTriageRulesTool(triageService: TriageRulesService): Dynami
 
         return JSON.stringify(result);
       } catch (error) {
-        logger.error('triage_rules tool error:', error);
+        logger.error({ error }, 'triage_rules tool error');
         return JSON.stringify({
           error: 'Failed to evaluate triage rules',
           triage: 'urgent',

src/routes/conversation.route.ts

@@ -95,7 +95,7 @@ export async function conversationRoutes(
         count: messages.length
       });
     } catch (error) {
-      logger.error('Get conversation history error:', error);
+      logger.error({ error }, 'Get conversation history error');
       return reply.status(500).send({
         error: 'Internal server error',
         message: 'Failed to get conversation history'
@@ -192,7 +192,7 @@ export async function conversationRoutes(
         count: sessions.length
       });
     } catch (error) {
-      logger.error('Get user sessions error:', error);
+      logger.error({ error }, 'Get user sessions error');
       return reply.status(500).send({
         error: 'Internal server error',
         message: 'Failed to get user sessions'

src/routes/cv.route.ts

@@ -1,11 +1,12 @@
 import { FastifyInstance, FastifyRequest, FastifyReply } from 'fastify';
-import { z } from 'zod';
+// import { z } from 'zod'; // Unused for now, can be used for future validation
 import { CVService } from '../services/cv.service.js';
 import { logger } from '../utils/logger.js';
 
-const imageUrlSchema = z.object({
-  image_url: z.string().url('Image URL must be a valid URL')
-});
+// Schema for image URL validation (can be used for future validation)
+// const imageUrlSchema = z.object({
+//   image_url: z.string().url('Image URL must be a valid URL')
+// });
 
 export async function cvRoutes(fastify: FastifyInstance) {
   const cvService = new CVService();
@@ -58,7 +59,7 @@ export async function cvRoutes(fastify: FastifyInstance) {
       const result = await cvService.callDermCV(request.body.image_url);
       return reply.status(200).send(result);
     } catch (error) {
-      logger.error('Derm CV endpoint error:', error);
+      logger.error({ error }, 'Derm CV endpoint error');
       return reply.status(500).send({
         error: 'Internal server error',
         message: 'Failed to analyze dermatology image'
@@ -113,7 +114,7 @@ export async function cvRoutes(fastify: FastifyInstance) {
       const result = await cvService.callEyeCV(request.body.image_url);
       return reply.status(200).send(result);
     } catch (error) {
-      logger.error('Eye CV endpoint error:', error);
+      logger.error({ error }, 'Eye CV endpoint error');
       return reply.status(500).send({
         error: 'Internal server error',
         message: 'Failed to analyze eye image'
@@ -168,7 +169,7 @@ export async function cvRoutes(fastify: FastifyInstance) {
       const result = await cvService.callWoundCV(request.body.image_url);
       return reply.status(200).send(result);
     } catch (error) {
-      logger.error('Wound CV endpoint error:', error);
+      logger.error({ error }, 'Wound CV endpoint error');
       return reply.status(500).send({
         error: 'Internal server error',
         message: 'Failed to analyze wound image'

src/routes/health.route.ts

@@ -1,10 +1,11 @@
 import { FastifyInstance, FastifyRequest, FastifyReply } from 'fastify';
-import { CVService } from '../services/cv.service.js';
+// import { CVService } from '../services/cv.service.js'; // Unused for now, can be used for future health checks
 import { config } from '../utils/config.js';
 import { logger } from '../utils/logger.js';
 
 export async function healthRoutes(fastify: FastifyInstance) {
-  const cvService = new CVService();
+  // CV service can be used for health checks in the future
+  // const cvService = new CVService();
 
   fastify.get('/health', {
     schema: {
@@ -38,7 +39,7 @@ export async function healthRoutes(fastify: FastifyInstance) {
         }
       }
     }
-  }, async (request: FastifyRequest, reply: FastifyReply) => {
+  }, async (_request: FastifyRequest, reply: FastifyReply) => {
     try {
       logger.info('Health check requested');
 
@@ -75,7 +76,7 @@ export async function healthRoutes(fastify: FastifyInstance) {
 
       return reply.status(200).send(health);
     } catch (error) {
-      logger.error('Health check error:', error);
+      logger.error({ error }, 'Health check error');
       return reply.status(500).send({
         status: 'error',
         message: 'Health check failed'

src/routes/maps.route.ts

@@ -1,14 +1,15 @@
 import { FastifyInstance, FastifyRequest, FastifyReply } from 'fastify';
-import { z } from 'zod';
+// import { z } from 'zod'; // Unused for now, can be used for future validation
 import { MapsService } from '../services/maps.service.js';
 import { logger } from '../utils/logger.js';
 import type { Location } from '../types/index.js';
 
-const locationSchema = z.object({
-  lat: z.number().min(-90).max(90),
-  lng: z.number().min(-180).max(180),
-  keyword: z.string().optional()
-});
+// Schema for location validation (can be used for future validation)
+// const locationSchema = z.object({
+//   lat: z.number().min(-90).max(90),
+//   lng: z.number().min(-180).max(180),
+//   keyword: z.string().optional()
+// });
 
 export async function mapsRoutes(fastify: FastifyInstance) {
   const mapsService = new MapsService();
@@ -89,7 +90,7 @@ export async function mapsRoutes(fastify: FastifyInstance) {
 
       return reply.status(200).send(clinic);
     } catch (error) {
-      logger.error('Maps endpoint error:', error);
+      logger.error({ error }, 'Maps endpoint error');
       return reply.status(500).send({
         error: 'Internal server error',
         message: 'Failed to find nearest clinic'

src/routes/rag.route.ts

@@ -1,15 +1,16 @@
 import { FastifyInstance, FastifyRequest, FastifyReply } from 'fastify';
-import { z } from 'zod';
+// import { z } from 'zod'; // Unused for now, can be used for future validation
 import { RAGService } from '../services/rag.service.js';
 import { SupabaseService } from '../services/supabase.service.js';
 import { logger } from '../utils/logger.js';
 import type { GuidelineQuery } from '../types/index.js';
 
-const guidelineQuerySchema = z.object({
-  symptoms: z.string().min(1),
-  suspected_conditions: z.array(z.string()).optional(),
-  triage_level: z.string().optional()
-});
+// Schema for guideline query validation (can be used for future validation)
+// const guidelineQuerySchema = z.object({
+//   symptoms: z.string().min(1),
+//   suspected_conditions: z.array(z.string()).optional(),
+//   triage_level: z.string().optional()
+// });
 
 export async function ragRoutes(
   fastify: FastifyInstance,
@@ -82,7 +83,7 @@ export async function ragRoutes(
         count: guidelines.length
       });
     } catch (error) {
-      logger.error('RAG search endpoint error:', error);
+      logger.error({ error }, 'RAG search endpoint error');
       return reply.status(500).send({
         error: 'Internal server error',
         message: 'Failed to search guidelines'

src/routes/sessions.route.ts

@@ -63,7 +63,7 @@ export async function sessionsRoutes(
 
       return reply.status(200).send(session);
     } catch (error) {
-      logger.error('Get session endpoint error:', error);
+      logger.error({ error }, 'Get session endpoint error');
       return reply.status(500).send({
         error: 'Internal server error',
         message: 'Failed to get session'

src/routes/triage-rules.route.ts

@@ -1,24 +1,25 @@
 import { FastifyInstance, FastifyRequest, FastifyReply } from 'fastify';
-import { z } from 'zod';
+// import { z } from 'zod'; // Unused for now, can be used for future validation
 import { TriageRulesService } from '../services/triage-rules.service.js';
 import { logger } from '../utils/logger.js';
 import type { TriageInput } from '../types/index.js';
 
-const triageInputSchema = z.object({
-  symptoms: z.object({
-    main_complaint: z.string().min(1),
-    duration: z.string().optional(),
-    pain_severity: z.enum(['nhẹ', 'vừa', 'nặng']).optional(),
-    fever: z.boolean().optional(),
-    vision_changes: z.boolean().optional(),
-    bleeding: z.boolean().optional(),
-    breathing_difficulty: z.boolean().optional(),
-    chest_pain: z.boolean().optional(),
-    severe_headache: z.boolean().optional(),
-    confusion: z.boolean().optional()
-  }),
-  cv_results: z.any().optional()
-});
+// Schema for triage input validation (can be used for future validation)
+// const triageInputSchema = z.object({
+//   symptoms: z.object({
+//     main_complaint: z.string().min(1),
+//     duration: z.string().optional(),
+//     pain_severity: z.enum(['nhẹ', 'vừa', 'nặng']).optional(),
+//     fever: z.boolean().optional(),
+//     vision_changes: z.boolean().optional(),
+//     bleeding: z.boolean().optional(),
+//     breathing_difficulty: z.boolean().optional(),
+//     chest_pain: z.boolean().optional(),
+//     severe_headache: z.boolean().optional(),
+//     confusion: z.boolean().optional()
+//   }),
+//   cv_results: z.any().optional()
+// });
 
 export async function triageRulesRoutes(fastify: FastifyInstance) {
   const triageService = new TriageRulesService();
@@ -83,7 +84,7 @@ export async function triageRulesRoutes(fastify: FastifyInstance) {
       const result = triageService.evaluateSymptoms(request.body as TriageInput);
       return reply.status(200).send(result);
     } catch (error) {
-      logger.error('Triage rules endpoint error:', error);
+      logger.error({ error }, 'Triage rules endpoint error');
       return reply.status(500).send({
         error: 'Internal server error',
         message: 'Failed to evaluate triage rules'

src/routes/triage.route.ts

@@ -168,7 +168,7 @@ export async function triageRoutes(
       const validationResult = healthCheckSchema.safeParse(request.body);
       
       if (!validationResult.success) {
-        logger.warn('Invalid request body:', validationResult.error);
+        logger.warn({ error: validationResult.error }, 'Invalid request body');
         return reply.status(400).send({
           error: 'Invalid request',
           details: validationResult.error.errors
@@ -223,13 +223,12 @@ export async function triageRoutes(
       // Add user message to history
       await conversationService.addUserMessage(activeSessionId, user_id, normalizedText, normalizedImageUrl);
 
-      // Process triage with agent (pass conversation context and session ID for WebSocket streaming)
+      // Process triage with agent (pass conversation context)
       const triageResult = await agent.processTriage(
         normalizedText || 'Da tôi bị gì thế này',
         normalizedImageUrl,
         user_id,
-        conversationContext, // Pass context separately for better agent handling
-        activeSessionId // Pass session ID for WebSocket streaming
+        conversationContext // Pass context separately for better agent handling
       );
 
       // Add assistant response to conversation history
@@ -242,7 +241,7 @@ export async function triageRoutes(
           triageResult
         );
       } catch (error) {
-        logger.error('Failed to save conversation history:', error);
+        logger.error({ error }, 'Failed to save conversation history');
         // Continue even if saving fails
       }
 
@@ -256,7 +255,7 @@ export async function triageRoutes(
           location
         });
       } catch (error) {
-        logger.error('Failed to save session:', error);
+        logger.error({ error }, 'Failed to save session');
         // Continue even if saving fails
       }
 
@@ -266,7 +265,7 @@ export async function triageRoutes(
         try {
           nearestClinic = await mapsService.findNearestClinic(location);
         } catch (error) {
-          logger.error('Failed to find nearest clinic:', error);
+          logger.error({ error }, 'Failed to find nearest clinic');
           // Continue without clinic info
         }
       }
@@ -282,7 +281,7 @@ export async function triageRoutes(
 
       return reply.status(200).send(response);
     } catch (error) {
-      logger.error('Health check error:', error);
+      logger.error({ error }, 'Health check error');
       
       return reply.status(500).send({
         error: 'Internal server error',

src/routes/websocket.route.ts

@@ -4,10 +4,8 @@
  */
 
 import { FastifyInstance, FastifyRequest } from 'fastify';
-import { SocketStream } from '@fastify/websocket';
 import { wsConnectionManager } from '../services/websocket.service.js';
 import { logger } from '../utils/logger.js';
-
 interface WebSocketQueryString {
   session: string;
   token?: string;
@@ -18,13 +16,13 @@ export async function websocketRoutes(fastify: FastifyInstance) {
   fastify.get(
     '/ws/chat',
     { websocket: true },
-    async (connection: SocketStream, req: FastifyRequest) => {
-      const { session, token } = req.query as WebSocketQueryString;
+    async (connection, req: FastifyRequest) => {
+      const { session } = req.query as WebSocketQueryString;
 
       // Validate session parameter
       if (!session || typeof session !== 'string') {
         logger.warn('WebSocket connection rejected: missing session parameter');
-        connection.socket.close(1008, 'Session ID required');
+        connection.close(1008, 'Session ID required');
         return;
       }
 
@@ -43,11 +41,11 @@ export async function websocketRoutes(fastify: FastifyInstance) {
       logger.info(`WebSocket connection request for session: ${session}`);
 
       // Add connection to manager
-      wsConnectionManager.addConnection(session, connection.socket);
+      wsConnectionManager.addConnection(session, connection);
 
       // Send welcome message
       try {
-        connection.socket.send(
+        connection.send(
           JSON.stringify({
             type: 'connected',
             message: 'WebSocket connected successfully',
@@ -56,17 +54,17 @@ export async function websocketRoutes(fastify: FastifyInstance) {
           })
         );
       } catch (error) {
-        logger.error('Error sending welcome message:', error);
+        logger.error({ error }, 'Error sending welcome message');
       }
 
       // Handle incoming messages (optional - mainly for keep-alive pings)
-      connection.socket.on('message', (data: Buffer) => {
+      connection.on('message', (data: Buffer) => {
         try {
           const message = JSON.parse(data.toString());
 
           // Handle ping/pong
           if (message.type === 'ping') {
-            connection.socket.send(
+            connection.send(
               JSON.stringify({
                 type: 'pong',
                 timestamp: new Date().toISOString(),
@@ -80,7 +78,7 @@ export async function websocketRoutes(fastify: FastifyInstance) {
             logger.info(`Auth message received for session ${session}`);
           }
         } catch (error) {
-          logger.error(`Error processing WebSocket message for session ${session}:`, error);
+          logger.error({ error, session }, 'Error processing WebSocket message');
         }
       });
 

src/services/cv.service.ts

@@ -99,7 +99,7 @@ export class CVService {
       logger.info('[MCP CV] Calling Dermatology CV model...');
       return await this.callCVAPI(imageUrl, 'dermnet', 3);
     } catch (error) {
-      logger.error('[MCP CV] Derm CV error:', error);
+      logger.error({ error }, '[MCP CV] Derm CV error');
       return { top_conditions: [] };
     }
   }
@@ -110,7 +110,7 @@ export class CVService {
       // Eye conditions are also analyzed by dermnet model
       return await this.callCVAPI(imageUrl, 'dermnet', 3);
     } catch (error) {
-      logger.error('[MCP CV] Eye CV error:', error);
+      logger.error({ error }, '[MCP CV] Eye CV error');
       return { top_conditions: [] };
     }
   }
@@ -121,7 +121,7 @@ export class CVService {
       // Wound conditions are also analyzed by dermnet model
       return await this.callCVAPI(imageUrl, 'dermnet', 3);
     } catch (error) {
-      logger.error('[MCP CV] Wound CV error:', error);
+      logger.error({ error }, '[MCP CV] Wound CV error');
       return { top_conditions: [] };
     }
   }

src/services/intent-classifier.service.ts

@@ -32,10 +32,11 @@ export class IntentClassifierService {
     'thông tin về', 'tìm hiểu về', 'định nghĩa', 'nguyên nhân'
   ];
 
-  private readonly TREATMENT_KEYWORDS = [
-    'điều trị', 'chữa', 'phòng ngừa', 'phòng bệnh', 'cách chữa',
-    'cách điều trị', 'thuốc', 'liệu pháp'
-  ];
+  // Treatment keywords can be used for future treatment-related intent classification
+  // private readonly TREATMENT_KEYWORDS = [
+  //   'điều trị', 'chữa', 'phòng ngừa', 'phòng bệnh', 'cách chữa',
+  //   'cách điều trị', 'thuốc', 'liệu pháp'
+  // ];
 
   private readonly OUT_OF_SCOPE_KEYWORDS = [
     'bảo hiểm', 'bhyt', 'chi phí', 'giá', 'thủ tục',

src/services/maps.service.ts

@@ -54,7 +54,7 @@ export class MapsService {
       logger.warn('No clinics found nearby');
       return null;
     } catch (error) {
-      logger.error('Google Maps API error:', error);
+      logger.error({ error }, 'Google Maps API error');
       return null;
     }
   }

src/services/supabase.service.ts

@@ -38,13 +38,13 @@ export class SupabaseService {
         });
 
       if (error) {
-        logger.error('Error saving session:', error);
+        logger.error({ error }, 'Error saving session');
         throw error;
       }
 
       logger.info('Session saved successfully');
     } catch (error) {
-      logger.error('Failed to save session:', error);
+      logger.error({ error }, 'Failed to save session');
       throw error;
     }
   }
@@ -58,13 +58,13 @@ export class SupabaseService {
         .single();
 
       if (error) {
-        logger.error('Error fetching session:', error);
+        logger.error({ error }, 'Error fetching session');
         throw error;
       }
 
       return data;
     } catch (error) {
-      logger.error('Failed to fetch session:', error);
+      logger.error({ error }, 'Failed to fetch session');
       throw error;
     }
   }
@@ -80,7 +80,7 @@ export class SupabaseService {
 
       return { user_id: data.user.id };
     } catch (error) {
-      logger.error('Token verification failed:', error);
+      logger.error({ error }, 'Token verification failed');
       return null;
     }
   }

src/services/websocket.service.ts

@@ -23,7 +23,8 @@ export class WebSocketConnectionManager {
   // Configuration
   private readonly INACTIVITY_TIMEOUT = 30 * 60 * 1000; // 30 minutes
   private readonly RATE_LIMIT = 100; // messages per minute
-  private readonly RATE_LIMIT_WINDOW = 60 * 1000; // 1 minute
+  // Rate limit window can be used for future rate limiting implementation
+  // private readonly RATE_LIMIT_WINDOW = 60 * 1000; // 1 minute
 
   constructor() {
     // Start cleanup task
@@ -56,7 +57,7 @@ export class WebSocketConnectionManager {
     });
 
     ws.on('error', (error) => {
-      logger.error(`WebSocket error for session ${sessionId}:`, error);
+      logger.error({ error, sessionId }, 'WebSocket error');
       this.removeConnection(sessionId);
     });
   }
@@ -72,7 +73,7 @@ export class WebSocketConnectionManager {
           ws.close();
         }
       } catch (error) {
-        logger.error(`Error closing WebSocket for session ${sessionId}:`, error);
+        logger.error({ error, sessionId }, 'Error closing WebSocket');
       }
     }
 
@@ -116,11 +117,11 @@ export class WebSocketConnectionManager {
       const count = this.messageCount.get(sessionId) || 0;
       this.messageCount.set(sessionId, count + 1);
 
-      logger.debug(`Message sent to session ${sessionId}:`, { type: message.type });
+      logger.debug({ sessionId, messageType: message.type }, 'Message sent to session');
 
       return true;
     } catch (error) {
-      logger.error(`Error sending message to session ${sessionId}:`, error);
+      logger.error({ error, sessionId }, 'Error sending message');
       return false;
     }
   }

src/utils/swagger.ts

@@ -1,24 +1,22 @@
-import { FastifySwaggerOptions } from '@fastify/swagger';
-import { FastifySwaggerUiOptions } from '@fastify/swagger-ui';
+import type { FastifySwaggerUiOptions } from '@fastify/swagger-ui';
 
-export const swaggerOptions: FastifySwaggerOptions = {
-  openapi: {
-    openapi: '3.1.0',
-    info: {
-      title: 'MEDAGEN Backend API',
-      description: 'AI Triage Assistant API với ReAct Agent và Gemini 2.5Flash',
-      version: '2.0.0',
-      contact: {
-        name: 'MEDAGEN Team'
-      }
-    },
-    servers: [
+export const swaggerOptions = {
+  openapi: '3.1.0',
+  info: {
+    title: 'MEDAGEN Backend API',
+    description: 'AI Triage Assistant API với ReAct Agent và Gemini 2.5Flash',
+    version: '2.0.0',
+    contact: {
+      name: 'MEDAGEN Team'
+    }
+  },
+  servers: [
       {
         url: 'http://localhost:7860',
         description: 'Development server (Port 7860)'
       }
-    ],
-    tags: [
+  ],
+  tags: [
       {
         name: 'health',
         description: 'Health check endpoints'
@@ -47,8 +45,8 @@ export const swaggerOptions: FastifySwaggerOptions = {
         name: 'conversations',
         description: 'Conversation history endpoints'
       }
-    ],
-    components: {
+  ],
+  components: {
       schemas: {
         HealthCheckRequest: {
           type: 'object',
@@ -327,7 +325,6 @@ export const swaggerOptions: FastifySwaggerOptions = {
         }
       }
     }
-  }
 };
 
 export const swaggerUiOptions: FastifySwaggerUiOptions = {
@@ -339,7 +336,7 @@ export const swaggerUiOptions: FastifySwaggerUiOptions = {
     persistAuthorization: true
   },
   staticCSP: false, // Disable strict CSP to allow Swagger UI to fetch JSON
-  transformSpecification: (swaggerObject, request, reply) => {
+  transformSpecification: (swaggerObject, request) => {
     // Ensure servers URL matches current request
     if (swaggerObject.servers && swaggerObject.servers.length > 0) {
       const protocol = request.headers['x-forwarded-proto'] || (request.protocol || 'http');