fix healthcheck

client/src/components/ServiceStatus.jsx

@@ -1,4 +1,4 @@
-import React, { useState, useEffect } from "react";
+import React from "react";
 import { Box, Typography } from "@mui/material";
 import { styled } from "@mui/system";
 import { useServiceStatus } from "../contexts/ServiceStatusContext";
@@ -10,8 +10,6 @@ const StatusDot = styled("div")(({ status }) => ({
   backgroundColor:
     status === "healthy"
       ? "#4caf50"
-      : status === "initializing"
-      ? "#FFA726"
       : status === "unhealthy"
       ? "#f44336"
       : "#9e9e9e",
@@ -28,82 +26,30 @@ const ServiceLabel = styled(Box)({
   },
 });
 
-const ServiceStatusContainer = styled("div")({
-  position: "absolute",
-  top: 16,
-  left: 16,
-  padding: 8,
-  borderRadius: 4,
-  boxShadow: "0 2px 4px rgba(0,0,0,0.1)",
-  zIndex: 1000,
-});
-
 export function ServiceStatus() {
   const { services } = useServiceStatus();
 
-  const fetchServiceHealth = async (service) => {
-    try {
-      const response = await fetch(`/api/health/${service}`);
-      const data = await response.json();
-
-      if (response.ok) {
-        return {
-          status: data.status,
-          latency: data.latency,
-          error: null,
-        };
-      } else {
-        return {
-          status: data.status || "unhealthy",
-          latency: null,
-          error: data.error || "Service unavailable",
-        };
-      }
-    } catch (error) {
-      console.error(`Error checking ${service} health:`, error);
-      return {
-        status: "unhealthy",
-        latency: null,
-        error: error.message,
-      };
-    }
-  };
-
-  useEffect(() => {
-    const checkHealth = async () => {
-      const mistralHealth = await fetchServiceHealth("mistral");
-      const fluxHealth = await fetchServiceHealth("flux");
-
-      // Assuming you want to update the state with the fetched health data
-      // This is a placeholder and should be replaced with actual state management logic
-      console.log("Updating health status:", {
-        mistral: mistralHealth,
-        flux: fluxHealth,
-      });
-    };
-
-    // Initial check
-    checkHealth();
-
-    // Check every 30 seconds
-    const interval = setInterval(checkHealth, 30000);
-
-    return () => clearInterval(interval);
-  }, []);
-
   return (
-    <ServiceStatusContainer>
+    <Box
+      sx={{
+        position: "absolute",
+        top: 16,
+        left: 16,
+        display: "flex",
+        alignItems: "center",
+        zIndex: 1000,
+      }}
+    >
       {Object.entries(services).map(([service, { status, latency, error }]) => (
         <ServiceLabel key={service}>
           <StatusDot status={status} />
           <Typography>
             {service.charAt(0).toUpperCase() + service.slice(1)}
-            {/* {status === "healthy" && latency && ` (${Math.round(latency)}ms)`} */}
-            {/* {status === "initializing" && " (initializing...)"}
-            {status === "unhealthy" && error && ` (${error})`} */}
+            {/* {status === "healthy" && latency && ` (${latency}ms)`} */}
+            {/* {error && ` - ${error}`} */}
           </Typography>
         </ServiceLabel>
       ))}
-    </ServiceStatusContainer>
+    </Box>
   );
 }

client/src/contexts/ServiceStatusContext.jsx

@@ -63,26 +63,11 @@ export function ServiceStatusProvider({ children }) {
   };
 
   useEffect(() => {
-    console.log("ServiceStatusProvider mounted, initializing health checks...");
-    const checkHealth = () => {
-      console.log("Running health checks...");
-      fetchServiceHealth("mistral");
-      fetchServiceHealth("flux");
-    };
-
-    // Premier check immédiat
-    checkHealth();
-
-    // Mettre en place l'intervalle
-    console.log("Setting up health check interval...");
-    const interval = setInterval(checkHealth, 30000);
-
-    // Cleanup
-    return () => {
-      console.log("Cleaning up health check interval...");
-      clearInterval(interval);
-    };
-  }, []);
+    console.log("ServiceStatusProvider mounted, checking services health...");
+    // Un seul check au montage du composant
+    fetchServiceHealth("mistral");
+    fetchServiceHealth("flux");
+  }, []); // Pas d'intervalle, juste une vérification au montage
 
   return (
     <ServiceStatusContext.Provider value={{ services, areServicesHealthy }}>

client/src/pages/Tutorial.jsx

@@ -75,7 +75,7 @@ export function Tutorial() {
             zIndex: 10,
             textAlign: "center",
             mt: 2,
-            maxWidth: isMobile ? "85%" : "50%",
+            maxWidth: isMobile ? "85%" : "75%",
             opacity: 0.8,
             color: "white",
             px: isMobile ? 3 : 0,
@@ -105,7 +105,7 @@ export function Tutorial() {
               sx={{
                 position: "relative",
                 flex: { xs: "none", sm: 1 },
-                width: { xs: "50%", sm: "auto" },
+                width: { xs: "75%", sm: "auto" },
                 maxWidth: { xs: "160px", sm: "200px" },
                 "&::before": {
                   content: '""',

server/api/models.py

@@ -2,7 +2,6 @@ from pydantic import BaseModel, Field, validator
 from typing import List, Optional, Dict, Any, Union
 from core.constants import GameConfig
 import re
-from enum import Enum
 
 class Choice(BaseModel):
     id: int
@@ -85,13 +84,8 @@ class StoryResponse(BaseModel):
             raise ValueError('Must have exactly 2 choices for story progression')
         return v
 
-class ServiceStatus(str, Enum):
-    HEALTHY = "healthy"
-    UNHEALTHY = "unhealthy"
-    INITIALIZING = "initializing"
-
 class HealthCheckResponse(BaseModel):
-    status: ServiceStatus
-    service: str
-    latency: Optional[float] = None
-    error: Optional[str] = None
+    status: str = Field(..., description="The health status of the service (healthy/unhealthy)")
+    service: str = Field(..., description="The name of the service being checked")
+    latency: Optional[float] = Field(None, description="The latency of the service in milliseconds")
+    error: Optional[str] = Field(None, description="Error message if the service is unhealthy")

server/api/routes/health.py

@@ -58,43 +58,21 @@ def get_health_router(mistral_client: MistralClient, flux_client: FluxClient) ->
         start_time = time.time()
         try:
             # Try to generate a test image with a timeout
-            is_healthy, status = await asyncio.wait_for(
+            is_healthy = await asyncio.wait_for(
                 flux_client.check_health(),
                 timeout=5.0  # Même timeout que Mistral
             )
             
-            latency = (time.time() - start_time) * 1000  # Convert to milliseconds
-            
-            if is_healthy:
-                print(f"Flux health check successful. Latency: {latency}ms")
-                return HealthCheckResponse(
-                    status="healthy",
-                    service="flux",
-                    latency=latency
-                )
-            elif status == "initializing":
-                print("Flux service is initializing")
-                raise HTTPException(
-                    status_code=503,
-                    detail=HealthCheckResponse(
-                        status="initializing",
-                        service="flux",
-                        latency=None,
-                        error="Service is initializing"
-                    ).dict()
-                )
-            else:
-                print(f"Flux health check failed: {status}")
-                raise HTTPException(
-                    status_code=503,
-                    detail=HealthCheckResponse(
-                        status="unhealthy",
-                        service="flux",
-                        latency=None,
-                        error=status
-                    ).dict()
-                )
+            if not is_healthy:
+                raise Exception("Failed to generate test image")
                 
+            latency = (time.time() - start_time) * 1000  # Convert to milliseconds
+            print(f"Flux health check successful. Latency: {latency}ms")
+            return HealthCheckResponse(
+                status="healthy",
+                service="flux",
+                latency=latency
+            )
         except asyncio.TimeoutError:
             print("Flux health check failed: timeout")
             raise HTTPException(

server/services/flux_client.py

@@ -1,6 +1,6 @@
 import os
 import aiohttp
-from typing import Optional, Tuple
+from typing import Optional
 
 class FluxClient:
     def __init__(self, api_key: str):
@@ -18,7 +18,7 @@ class FluxClient:
                       width: int, 
                       height: int,
                       num_inference_steps: int = 5,
-                      guidance_scale: float = 9.0) -> Tuple[Optional[bytes], Optional[str]]:
+                      guidance_scale: float = 9.0) -> Optional[bytes]:
         """Génère une image à partir d'un prompt."""
         try:
             # Ensure dimensions are multiples of 8
@@ -29,6 +29,7 @@ class FluxClient:
             print(f"Headers: Authorization: Bearer {self.api_key[:4]}...")
             print(f"Request body: {prompt[:100]}...")
 
+            
             session = await self._get_session()
             async with session.post(
                 self.endpoint,
@@ -49,59 +50,51 @@ class FluxClient:
             ) as response:
                 print(f"Response status code: {response.status}")
                 print(f"Response headers: {response.headers}")
-                
-                # Vérifier si le modèle est en cours d'initialisation
-                if response.status == 503:
-                    error_content = await response.text()
-                    if "currently loading" in error_content.lower() or "initializing" in error_content.lower():
-                        return None, "initializing"
-                    return None, "unavailable"
+                print(f"Response content type: {response.headers.get('content-type', 'unknown')}")
                 
                 if response.status == 200:
                     content = await response.read()
-                    return content, None
+                    content_length = len(content)
+                    print(f"Received successful response with content length: {content_length}")
+                    if isinstance(content, bytes):
+                        print("Response content is bytes (correct)")
+                    else:
+                        print(f"Warning: Response content is {type(content)}")
+                    return content
                 else:
                     error_content = await response.text()
                     print(f"Error from Flux API: {response.status}")
                     print(f"Response content: {error_content}")
-                    return None, error_content
+                    return None
                 
         except Exception as e:
             print(f"Error in FluxClient.generate_image: {str(e)}")
             import traceback
             print(f"Traceback: {traceback.format_exc()}")
-            return None, str(e)
+            return None
             
     async def close(self):
         if self._session:
             await self._session.close()
             self._session = None
 
-    async def check_health(self) -> Tuple[bool, Optional[str]]:
+    async def check_health(self) -> bool:
         """
         Vérifie la disponibilité du service Flux en tentant de générer une petite image.
         
         Returns:
-            Tuple[bool, Optional[str]]: (is_healthy, status)
-            - is_healthy: True si le service est disponible
-            - status: "healthy", "initializing", ou message d'erreur
+            bool: True si le service est disponible, False sinon
         """
         try:
             # Test simple prompt pour générer une petite image
-            test_image, status = await self.generate_image(
+            test_image = await self.generate_image(
                 prompt="test image, simple circle",
                 width=64,  # Petite image pour le test
                 height=64,
                 num_inference_steps=1  # Minimum d'étapes pour être rapide
             )
             
-            if test_image is not None:
-                return True, "healthy"
-            elif status == "initializing":
-                return False, "initializing"
-            else:
-                return False, status or "unavailable"
-                
+            return test_image is not None
         except Exception as e:
             print(f"Health check failed: {str(e)}")
-            return False, str(e)
+            raise