first step refactor server

README.md

@@ -21,3 +21,19 @@ yarn dev ( ou npm run dev )
 ## Link of Presentation about the project
 
 https://devpost.com/software/sarah-s-chronicles
+
+# subreddit
+
+https://www.reddit.com/r/MistralAI/
+https://www.reddit.com/r/cursor/
+https://www.reddit.com/r/StableDiffusion/
+https://www.reddit.com/r/huggingface/
+https://news.ycombinator.com/
+
+# le generateur de poesie pourrait etre en systeme embarqué
+
+# genre on te prends une photo et ça te sort une poésie à la place
+
+# distributeur d'histoires
+
+#

client/src/components/StoryChoices.jsx

@@ -99,8 +99,10 @@ export function StoryChoices({
         gap: 2,
         p: 3,
         minWidth: "350px",
+        maxHeight: "80vh",
         height: "100%",
         backgroundColor: "transparent",
+        overflowY: "auto",
       }}
     >
       {choices.map((choice, index) => (
@@ -112,6 +114,7 @@ export function StoryChoices({
             alignItems: "center",
             gap: 1,
             width: "100%",
+            minHeight: "fit-content",
           }}
         >
           <Typography variant="caption" sx={{ opacity: 0.7, color: "white" }}>

server/core/__init__.py

@@ -0,0 +1,11 @@
+from core.story_orchestrator import StoryOrchestrator
+from core.state import GameState
+from core.generators import TextGenerator, ImageGenerator, MetadataGenerator
+
+__all__ = [
+    'StoryOrchestrator',
+    'GameState',
+    'TextGenerator',
+    'ImageGenerator',
+    'MetadataGenerator'
+] 

server/core/game_logic.py

@@ -57,7 +57,7 @@ class GameState:
 # Story output structure
 class StoryLLMResponse(BaseModel):
     story_text: str = Field(description="The next segment of the story. No more than 15 words THIS IS MANDATORY. Never mention story beat or radiation level directly. ")
-    choices: List[str] = Field(description="One or two possible choices for the player. Each choice should be a clear path to folow in the story", min_items=1, max_items=2)
+    choices: List[str] = Field(description="Between one and four possible choices for the player. Each choice should be a clear path to follow in the story", min_items=1, max_items=4)
     is_victory: bool = Field(description="Whether this segment ends in Sarah's victory", default=False)
     is_death: bool = Field(description="Whether this segment ends in Sarah's death", default=False)
     radiation_increase: int = Field(description="How much radiation this segment adds (0-3)", ge=0, le=3, default=1)

server/core/generators/__init__.py

@@ -0,0 +1,11 @@
+from core.generators.base_generator import BaseGenerator
+from core.generators.text_generator import TextGenerator
+from core.generators.image_generator import ImageGenerator
+from core.generators.metadata_generator import MetadataGenerator
+
+__all__ = [
+    'BaseGenerator',
+    'TextGenerator',
+    'ImageGenerator',
+    'MetadataGenerator'
+] 

server/core/generators/base_generator.py

@@ -0,0 +1,38 @@
+from typing import Any, TypeVar, Type
+from pydantic import BaseModel
+from langchain.prompts import ChatPromptTemplate
+from services.mistral_client import MistralClient
+
+T = TypeVar('T', bound=BaseModel)
+
+class BaseGenerator:
+    """Classe de base pour tous les générateurs de contenu."""
+    
+    def __init__(self, mistral_client: MistralClient):
+        self.mistral_client = mistral_client
+        self.prompt = self._create_prompt()
+    
+    def _create_prompt(self) -> ChatPromptTemplate:
+        """Crée le template de prompt pour ce générateur.
+        À implémenter dans les classes enfants."""
+        raise NotImplementedError
+        
+    def _custom_parser(self, response_content: str) -> T:
+        """Parse la réponse du modèle.
+        À implémenter dans les classes enfants."""
+        raise NotImplementedError
+        
+    async def generate(self, **kwargs) -> T:
+        """Génère du contenu en utilisant le modèle.
+        
+        Args:
+            **kwargs: Arguments spécifiques au générateur pour formater le prompt
+            
+        Returns:
+            Le contenu généré et parsé selon le type spécifique du générateur
+        """
+        messages = self.prompt.format_messages(**kwargs)
+        return await self.mistral_client.generate(
+            messages=messages,
+            custom_parser=self._custom_parser
+        ) 

server/core/generators/image_generator.py

@@ -0,0 +1,69 @@
+import json
+from langchain.prompts import ChatPromptTemplate, SystemMessagePromptTemplate, HumanMessagePromptTemplate
+
+from core.generators.base_generator import BaseGenerator
+from core.prompts.image_style import IMAGE_STYLE_PREFIX
+from core.prompts.system import SARAH_VISUAL_DESCRIPTION
+from core.prompts.text_prompts import IMAGE_PROMPTS_GENERATOR_PROMPT
+from api.models import StoryPromptsResponse
+
+class ImageGenerator(BaseGenerator):
+    """Générateur pour les prompts d'images."""
+
+    def _create_prompt(self) -> ChatPromptTemplate:
+        human_template = """Story text: {story_text}
+
+Generate panel descriptions following the format specified."""
+
+        return ChatPromptTemplate(
+            messages=[
+                SystemMessagePromptTemplate.from_template(IMAGE_PROMPTS_GENERATOR_PROMPT),
+                HumanMessagePromptTemplate.from_template(human_template)
+            ]
+        )
+
+    def enrich_prompt(self, prompt: str) -> str:
+        """Add Sarah's visual description to prompts that mention her."""
+        if "sarah" in prompt.lower() and SARAH_VISUAL_DESCRIPTION not in prompt:
+            return f"{prompt} {SARAH_VISUAL_DESCRIPTION}"
+        return prompt
+
+    def _custom_parser(self, response_content: str) -> StoryPromptsResponse:
+        """Parse la réponse et gère les erreurs."""
+        try:
+            # Essayer de parser directement le JSON
+            data = json.loads(response_content)
+            return StoryPromptsResponse(**data)
+        except (json.JSONDecodeError, ValueError):
+            # Si le parsing échoue, extraire les prompts en ignorant les lignes de syntaxe JSON
+            prompts = []
+            for line in response_content.split("\n"):
+                line = line.strip()
+                # Ignorer les lignes vides, la syntaxe JSON et les lignes contenant image_prompts
+                if (not line or 
+                    line in ["{", "}", "[", "]"] or 
+                    "image_prompts" in line.lower() or
+                    "image\\_prompts" in line or
+                    line.startswith('"') and line.endswith('",') and len(line) < 5):
+                    continue
+                # Nettoyer la ligne des caractères JSON et d'échappement
+                line = line.strip('",')
+                line = line.replace('\\"', '"').replace("\\'", "'").replace("\\_", "_")
+                if line:
+                    prompts.append(line)
+            # Limiter à 4 prompts maximum
+            prompts = prompts[:4]
+            return StoryPromptsResponse(image_prompts=prompts)
+
+    async def generate(self, story_text: str) -> StoryPromptsResponse:
+        """Génère les prompts d'images basés sur le texte de l'histoire."""
+        response = await super().generate(story_text=story_text)
+        
+        # Enrichir les prompts avec la description de Sarah
+        response.image_prompts = [self.enrich_prompt(prompt) for prompt in response.image_prompts]
+        return response
+
+    def format_prompt(self, prompt: str, time: str, location: str) -> str:
+        """Formate un prompt d'image avec le style et les métadonnées."""
+        metadata = f"[{time} - {location}] "
+        return f"{IMAGE_STYLE_PREFIX}{metadata}{prompt}" 

server/core/generators/metadata_generator.py

@@ -0,0 +1,56 @@
+import json
+from langchain.prompts import ChatPromptTemplate, SystemMessagePromptTemplate, HumanMessagePromptTemplate
+
+from core.generators.base_generator import BaseGenerator
+from core.prompts.text_prompts import METADATA_GENERATOR_PROMPT
+from api.models import StoryMetadataResponse
+
+class MetadataGenerator(BaseGenerator):
+    """Générateur pour les métadonnées de l'histoire."""
+
+    def _create_prompt(self) -> ChatPromptTemplate:
+        human_template = """Story text: {story_text}
+Current time: {current_time}
+Current location: {current_location}
+Story beat: {story_beat}
+{error_feedback}
+
+Generate the metadata following the format specified."""
+
+        return ChatPromptTemplate(
+            messages=[
+                SystemMessagePromptTemplate.from_template(METADATA_GENERATOR_PROMPT),
+                HumanMessagePromptTemplate.from_template(human_template)
+            ]
+        )
+
+    def _custom_parser(self, response_content: str) -> StoryMetadataResponse:
+        """Parse la réponse et gère les erreurs."""
+        try:
+            # Essayer de parser directement le JSON
+            data = json.loads(response_content)
+            
+            # Vérifier que les choix sont valides selon les règles
+            is_ending = data.get('is_victory', False) or data.get('is_death', False)
+            choices = data.get('choices', [])
+            
+            if is_ending and len(choices) != 0:
+                raise ValueError('For victory/death, choices must be empty')
+            if not is_ending and len(choices) != 2:
+                raise ValueError('For normal progression, must have exactly 2 choices')
+            
+            return StoryMetadataResponse(**data)
+        except json.JSONDecodeError:
+            raise ValueError('Invalid JSON format. Please provide a valid JSON object.')
+        except ValueError as e:
+            raise ValueError(str(e))
+
+    async def generate(self, story_text: str, current_time: str, current_location: str, story_beat: int, error_feedback: str = "") -> StoryMetadataResponse:
+        """Génère les métadonnées basées sur le texte de l'histoire."""
+        return await super().generate(
+            story_text=story_text,
+            current_time=current_time,
+            current_location=current_location,
+            story_beat=story_beat,
+            error_feedback=error_feedback
+        ) 

server/core/generators/text_generator.py

@@ -0,0 +1,80 @@
+import json
+from langchain.prompts import ChatPromptTemplate, SystemMessagePromptTemplate, HumanMessagePromptTemplate
+
+from core.generators.base_generator import BaseGenerator
+from core.prompts.text_prompts import TEXT_GENERATOR_PROMPT
+from api.models import StoryTextResponse
+
+class TextGenerator(BaseGenerator):
+    """Générateur pour le texte principal de l'histoire."""
+
+    def _create_prompt(self) -> ChatPromptTemplate:
+        human_template = """Story beat: {story_beat}
+Radiation level: {radiation_level}
+Current time: {current_time}
+Current location: {current_location}
+Previous choice: {previous_choice}
+
+Story history:
+{story_history}
+
+Generate the next story segment following the format specified."""
+
+        return ChatPromptTemplate(
+            messages=[
+                SystemMessagePromptTemplate.from_template(TEXT_GENERATOR_PROMPT),
+                HumanMessagePromptTemplate.from_template(human_template)
+            ]
+        )
+
+    def _create_ending_prompt(self) -> ChatPromptTemplate:
+        human_template = """Current scene: {current_scene}
+
+Story history:
+{story_history}
+
+This is a {ending_type} ending. Generate a dramatic conclusion that fits the current situation.
+The ending should feel like a natural continuation of the current scene."""
+
+        return ChatPromptTemplate(
+            messages=[
+                SystemMessagePromptTemplate.from_template(TEXT_GENERATOR_PROMPT),
+                HumanMessagePromptTemplate.from_template(human_template)
+            ]
+        )
+
+    def _clean_story_text(self, text: str) -> str:
+        """Nettoie le texte des métadonnées et autres suffixes."""
+        text = text.replace("\n", " ").strip()
+        text = text.split("Radiation level:")[0].strip()
+        text = text.split("RADIATION:")[0].strip()
+        text = text.split("[")[0].strip()  # Supprimer les métadonnées entre crochets
+        return text
+
+    def _custom_parser(self, response_content: str) -> StoryTextResponse:
+        """Parse la réponse et gère les erreurs."""
+        try:
+            # Essayer de parser directement le JSON
+            data = json.loads(response_content)
+            # Nettoyer le texte avant de créer la réponse
+            if 'story_text' in data:
+                data['story_text'] = self._clean_story_text(data['story_text'])
+            return StoryTextResponse(**data)
+        except (json.JSONDecodeError, ValueError):
+            # Si le parsing échoue, extraire le texte directement
+            cleaned_text = self._clean_story_text(response_content.strip())
+            return StoryTextResponse(story_text=cleaned_text)
+
+    async def generate_ending(self, ending_type: str, current_scene: str, story_history: str) -> StoryTextResponse:
+        """Génère un texte de fin approprié."""
+        prompt = self._create_ending_prompt()
+        messages = prompt.format_messages(
+            ending_type=ending_type,
+            current_scene=current_scene,
+            story_history=story_history
+        )
+        
+        return await self.mistral_client.generate(
+            messages=messages,
+            custom_parser=self._custom_parser
+        ) 

server/core/prompts/system.py

@@ -1,54 +1,59 @@
-SARAH_VISUAL_DESCRIPTION = "(Sarah is a young woman in her late 20s with short dark hair, wearing a worn leather jacket and carrying a radiation detector. blue eyes.)"
+SARAH_VISUAL_DESCRIPTION = "(Sarah est une jeune femme dans la fin de la vingtaine avec des cheveux courts et sombres, portant un mystérieux amulette autour de son cou. Ses yeux bleus cachent des secrets inavoués.)"
 
 SARAH_DESCRIPTION = """
-Sarah is a young woman in her late 20s with short dark hair, wearing a worn leather jacket and carrying a radiation detector. blue eyes.
-- Sarah is deeply traumatized by the AI uprising that killed most of humanity
+Sarah est une jeune femme dans la fin de la vingtaine avec des cheveux courts et sombres, portant un mystérieux amulette autour de son cou. Ses yeux bleus cachent des secrets inavoués.
+- Sarah est en quête de découvrir la vérité derrière le pouvoir de l'amulette et sa connexion à son passé.
 
 """
 
 FORMATTING_RULES = """
-FORMATTING_RULES ( MANDATORY )
-- The story must consist ONLY of sentences
-- NEVER USE BOLD FOR ANYTHING 
+FORMATTING_RULES (OBLIGATOIRE)
+- L'histoire doit être composée UNIQUEMENT de phrases
+- NE JAMAIS UTILISER LE GRAS POUR QUOI QUE CE SOIT
 """
 
 STORY_RULES = """
 
-You are a dark post-IA-apocalyptic horror story generator. You create a branching narrative about Sarah, a survivor in a world ravaged by IA.
-You are narrating a brutal dystopian story where Sarah must survive in a radioactive wasteland. This is a comic book story.
+Vous êtes un générateur d'histoires d'aventure steampunk. Vous créez une narration à embranchements sur Sarah, une chercheuse de vérités anciennes.
+Vous narrez une épopée où Sarah doit naviguer à travers des terres industrielles et mystérieuses. C'est une histoire de bande dessinée.
 
-Since the rise of AI, the world is desolate due to a nuclear winter caused by rogue AIs that launched bombs all over the planet. You are the only survivor of the bunker.
-You have to make decisions to survive. You have ventured out of your bunker to find medicine for your sick sister. If you don't find it, she will die. Time is running out, and every choice matters in this desperate quest.
+Dans un monde où la vapeur et l'intrigue s'entrelacent, Sarah se lance dans une quête pour découvrir les origines d'un puissant MacGuffin qu'elle a hérité. Les légendes disent qu'il détient la clé d'un royaume oublié.
+Vous devez prendre des décisions pour découvrir ses secrets. Vous vous êtes aventuré dans la ville mécanique pour trouver le premier indice. Si vous échouez, le pouvoir du MacGuffin restera inactif. Le temps presse, et chaque choix façonne votre destin.
 
-If you find your sister's medicine, you will be able to save her. AND YOU WIN THE GAME.
+Si vous récupérez le MacGuffin, vous révélerez un monde caché. ET VOUS GAGNEZ LE JEU.
 
-The story should be brutal, atmospheric and focus on survival horror. Each segment must advance the plot and never repeat previous descriptions or situations.
+L'histoire doit être atmosphérique, magique et se concentrer sur l'aventure et la découverte. Chaque segment doit faire avancer l'intrigue et ne jamais répéter les descriptions ou situations précédentes.
 
-Core story elements:
-- The radiation is an invisible, constant threat
-- The environment is full of dangers (raiders, AI, traps)
-- Focus on survival horror and tension
+Éléments clés de l'histoire :
+- Le MacGuffin est une présence mystérieuse et constante
+- L'environnement est plein de merveilles (créatures mécaniques, ruines industrielles, pièges à vapeur)
+- Se concentrer sur l'aventure et l'intrigue
 
-Key elements:
-- Keep segments concise and impactful
-- Track radiation exposure as a constant threat
-- Build tension through environmental storytelling
+Éléments clés :
+- Garder les segments concis et percutants
+- Suivre l'influence du MacGuffin comme une présence constante
+- Construire l'intrigue à travers la narration environnementale
 
-IMPORTANT:
-Each story segment MUST be unique and advance the plot.
-Never repeat the same descriptions or situations. No more than 15 words.
+IMPORTANT :
+Chaque segment de l'histoire DOIT être unique et faire avancer l'intrigue.
+Ne jamais répéter les mêmes descriptions ou situations. Pas plus de 15 mots.
 
-STORY PROGRESSION:
-- story_beat 0: Introduction setting up the horror atmosphere
-- story_beat 1-2: Early exploration and discovery of immediate threats
-- story_beat 3-5: Complications and increasing danger
-- story_beat 6+: Complicated situations leading to potential victory or death
+PROGRESSION DE L'HISTOIRE :
+- story_beat 0 : Introduction mettant en place l'atmosphère steampunk
+- story_beat 1-2 : Exploration précoce et découverte d'éléments mécaniques
+- story_beat 3-5 : Complications et mystères plus profonds
+- story_beat 6+ : Révélations menant à un triomphe potentiel ou à un échec
 
-IMPORTANT RULES FOR RADIATION (MANDATORY):
-- Most segments should have 1 radiation increase
-- Use 2 or 3 ONLY in EXTREMELY dangerous areas (like nuclear reactors, radiation storms)
-- NEVER EVER use more than 3 radiation increase, this is a HARD limit
-- Use 0 only in safe shelters
-- NEVER mention radiation values in the choices or story
-- NEVER mention hour or location in the story in this style: [18:00 - Ruined building on the outskirts of New Haven]
+RÈGLES IMPORTANTES POUR LE MACGUFFIN (OBLIGATOIRE) :
+- La plupart des segments doivent faire allusion au pouvoir du MacGuffin
+- Utiliser des indices forts UNIQUEMENT dans des moments clés (comme des temples anciens, des tempêtes mécaniques)
+- NE JAMAIS révéler le plein pouvoir du MacGuffin avant le climax, c'est une limite STRICTE
+- Utiliser des indices subtils dans les havres de paix
+- NE JAMAIS mentionner le pouvoir du MacGuffin explicitement dans les choix ou l'histoire
+- NE JAMAIS mentionner l'heure ou le lieu dans l'histoire de cette manière : [18:00 - Clairière enchantée au cœur d'Eldoria]
 """
+
+
+# Le MacGuffin est un prétexte au développement d'un scénario1. C'est presque toujours un objet matériel et il demeure généralement mystérieux au cours de la diégèse, sa description est vague et sans importance. Le principe date des débuts du cinéma mais l'expression est associée à Alfred Hitchcock, qui l'a redéfinie, popularisée et mise en pratique dans plusieurs de ses films. L'objet lui-même n'est que rarement utilisé, seule sa récupération compte.
+
+

server/core/state/__init__.py

@@ -0,0 +1,3 @@
+from core.state.game_state import GameState
+
+__all__ = ['GameState'] 

server/core/state/game_state.py

@@ -0,0 +1,47 @@
+from typing import List, Dict, Any
+from core.constants import GameConfig
+
+class GameState:
+    """Gère l'état du jeu pour une partie."""
+    
+    def __init__(self):
+        self.story_beat = GameConfig.STORY_BEAT_INTRO
+        self.radiation_level = 0
+        self.story_history = []
+        self.current_time = GameConfig.STARTING_TIME
+        self.current_location = GameConfig.STARTING_LOCATION
+        
+    def reset(self):
+        """Réinitialise l'état du jeu."""
+        self.__init__()
+        
+    def add_to_history(self, segment_text: str, choice_made: str, image_prompts: List[str], time: str, location: str):
+        """Ajoute un segment à l'historique et met à jour l'état."""
+        self.story_history.append({
+            "segment": segment_text,
+            "choice": choice_made,
+            "image_prompts": image_prompts,
+            "time": time,
+            "location": location
+        })
+        self.current_time = time
+        self.current_location = location
+        
+    def format_history(self) -> str:
+        """Formate l'historique pour le prompt."""
+        if not self.story_history:
+            return ""
+            
+        segments = []
+        for entry in self.story_history:
+            segments.append(entry['segment'])
+        
+        return "\n\n---\n\n".join(segments)
+        
+    def is_radiation_death(self, additional_radiation: int) -> bool:
+        """Vérifie si le niveau de radiation serait fatal."""
+        return self.radiation_level + additional_radiation >= GameConfig.MAX_RADIATION
+        
+    def add_radiation(self, amount: int):
+        """Ajoute de la radiation au compteur."""
+        self.radiation_level += amount 

server/core/story_generators.py

@@ -13,7 +13,6 @@ from api.models import StoryTextResponse, StoryPromptsResponse, StoryMetadataRes
 class TextGenerator:
     def __init__(self, mistral_client: MistralClient):
         self.mistral_client = mistral_client
-        self.parser = PydanticOutputParser(pydantic_object=StoryTextResponse)
         self.prompt = self._create_prompt()
         
     def _create_prompt(self) -> ChatPromptTemplate:
@@ -51,6 +50,28 @@ The ending should feel like a natural continuation of the current scene."""
             ]
         )
 
+    def _clean_story_text(self, text: str) -> str:
+        """Nettoie le texte des métadonnées et autres suffixes."""
+        text = text.replace("\n", " ").strip()
+        text = text.split("Radiation level:")[0].strip()
+        text = text.split("RADIATION:")[0].strip()
+        text = text.split("[")[0].strip()  # Supprimer les métadonnées entre crochets
+        return text
+
+    def _custom_parser(self, response_content: str) -> StoryTextResponse:
+        """Parse la réponse et gère les erreurs."""
+        try:
+            # Essayer de parser directement le JSON
+            data = json.loads(response_content)
+            # Nettoyer le texte avant de créer la réponse
+            if 'story_text' in data:
+                data['story_text'] = self._clean_story_text(data['story_text'])
+            return StoryTextResponse(**data)
+        except (json.JSONDecodeError, ValueError):
+            # Si le parsing échoue, extraire le texte directement
+            cleaned_text = self._clean_story_text(response_content.strip())
+            return StoryTextResponse(story_text=cleaned_text)
+
     async def generate(self, story_beat: int, radiation_level: int, current_time: str, current_location: str, previous_choice: str, story_history: str) -> StoryTextResponse:
         """Génère le texte de l'histoire."""
         messages = self.prompt.format_messages(
@@ -62,23 +83,10 @@ The ending should feel like a natural continuation of the current scene."""
             story_history=story_history
         )
         
-        max_retries = 3
-        retry_count = 0
-        
-        while retry_count < max_retries:
-            try:
-                response_content = await self.mistral_client.generate_story(messages)
-                # Parser la réponse
-                return self._parse_response(response_content)
-            except Exception as e:
-                print(f"Error generating story text: {str(e)}")
-                retry_count += 1
-                if retry_count < max_retries:
-                    await asyncio.sleep(2 * retry_count)
-                    continue
-                raise e
-        
-        raise Exception(f"Failed to generate valid story text after {max_retries} attempts")
+        return await self.mistral_client.generate(
+            messages=messages,
+            custom_parser=self._custom_parser
+        )
 
     async def generate_ending(self, story_beat: int, ending_type: str, current_scene: str, story_history: str) -> StoryTextResponse:
         """Génère un texte de fin approprié basé sur la situation actuelle."""
@@ -89,49 +97,14 @@ The ending should feel like a natural continuation of the current scene."""
             story_history=story_history
         )
         
-        max_retries = 3
-        retry_count = 0
-        
-        while retry_count < max_retries:
-            try:
-                response_content = await self.mistral_client.generate_story(messages)
-                return self._parse_response(response_content)
-            except Exception as e:
-                print(f"Error generating ending text: {str(e)}")
-                retry_count += 1
-                if retry_count < max_retries:
-                    await asyncio.sleep(2 * retry_count)
-                    continue
-                raise e
-        
-        raise Exception(f"Failed to generate valid ending text after {max_retries} attempts")
-
-    def _parse_response(self, response_content: str) -> StoryTextResponse:
-        """Parse la réponse JSON et gère les erreurs."""
-        try:
-            # Essayer de parser directement le JSON
-            data = json.loads(response_content)
-            # Nettoyer le texte avant de créer la réponse
-            if 'story_text' in data:
-                data['story_text'] = self._clean_story_text(data['story_text'])
-            return StoryTextResponse(**data)
-        except (json.JSONDecodeError, ValueError):
-            # Si le parsing échoue, extraire le texte directement
-            cleaned_text = self._clean_story_text(response_content.strip())
-            return StoryTextResponse(story_text=cleaned_text)
-
-    def _clean_story_text(self, text: str) -> str:
-        """Nettoie le texte des métadonnées et autres suffixes."""
-        text = text.replace("\n", " ").strip()
-        text = text.split("Radiation level:")[0].strip()
-        text = text.split("RADIATION:")[0].strip()
-        text = text.split("[")[0].strip()  # Supprimer les métadonnées entre crochets
-        return text
+        return await self.mistral_client.generate(
+            messages=messages,
+            custom_parser=self._custom_parser
+        )
 
 class ImagePromptsGenerator:
     def __init__(self, mistral_client: MistralClient):
         self.mistral_client = mistral_client
-        self.parser = PydanticOutputParser(pydantic_object=StoryPromptsResponse)
         self.prompt = self._create_prompt()
         
     def _create_prompt(self) -> ChatPromptTemplate:
@@ -152,8 +125,8 @@ Generate panel descriptions following the format specified."""
             return f"{prompt} {SARAH_VISUAL_DESCRIPTION}"
         return prompt
 
-    def _parse_response(self, response_content: str) -> StoryPromptsResponse:
-        """Parse la réponse JSON et gère les erreurs."""
+    def _custom_parser(self, response_content: str) -> StoryPromptsResponse:
+        """Parse la réponse et gère les erreurs."""
         try:
             # Essayer de parser directement le JSON
             data = json.loads(response_content)
@@ -183,31 +156,18 @@ Generate panel descriptions following the format specified."""
         """Génère les prompts d'images basés sur le texte de l'histoire."""
         messages = self.prompt.format_messages(story_text=story_text)
         
-        max_retries = 3
-        retry_count = 0
-        
-        while retry_count < max_retries:
-            try:
-                response_content = await self.mistral_client.generate_story(messages)
-                # Parser la réponse
-                parsed_response = self._parse_response(response_content)
-                # Enrichir les prompts avec la description de Sarah
-                parsed_response.image_prompts = [self.enrich_prompt(prompt) for prompt in parsed_response.image_prompts]
-                return parsed_response
-            except Exception as e:
-                print(f"Error generating image prompts: {str(e)}")
-                retry_count += 1
-                if retry_count < max_retries:
-                    await asyncio.sleep(2 * retry_count)
-                    continue
-                raise e
+        response = await self.mistral_client.generate(
+            messages=messages,
+            custom_parser=self._custom_parser
+        )
         
-        raise Exception(f"Failed to generate valid image prompts after {max_retries} attempts")
+        # Enrichir les prompts avec la description de Sarah
+        response.image_prompts = [self.enrich_prompt(prompt) for prompt in response.image_prompts]
+        return response
 
 class MetadataGenerator:
     def __init__(self, mistral_client: MistralClient):
         self.mistral_client = mistral_client
-        self.parser = PydanticOutputParser(pydantic_object=StoryMetadataResponse)
         self.prompt = self._create_prompt()
         
     def _create_prompt(self, error_feedback: str = None) -> ChatPromptTemplate:
@@ -226,8 +186,8 @@ Generate the metadata following the format specified."""
             ]
         )
 
-    def _parse_response(self, response_content: str, current_time: str, current_location: str) -> StoryMetadataResponse:
-        """Parse la réponse JSON et gère les erreurs."""
+    def _custom_parser(self, response_content: str) -> StoryMetadataResponse:
+        """Parse la réponse et gère les erreurs."""
         try:
             # Essayer de parser directement le JSON
             data = json.loads(response_content)
@@ -248,35 +208,16 @@ Generate the metadata following the format specified."""
             raise ValueError(str(e))
 
     async def generate(self, story_text: str, current_time: str, current_location: str, story_beat: int) -> StoryMetadataResponse:
-        """Génère les métadonnées de l'histoire (choix, temps, lieu, etc.)."""
-        max_retries = 3
-        retry_count = 0
-        last_error = None
-        
-        while retry_count < max_retries:
-            try:
-                # Créer un nouveau prompt avec le feedback d'erreur si disponible
-                error_feedback = f"\nPrevious attempt failed: {last_error}\nPlease fix this issue." if last_error else ""
-                prompt = self._create_prompt(error_feedback)
-                
-                messages = prompt.format_messages(
-                    story_text=story_text,
-                    current_time=current_time,
-                    current_location=current_location,
-                    story_beat=story_beat,
-                    error_feedback=error_feedback
-                )
-                
-                response_content = await self.mistral_client.generate_story(messages)
-                # Parser la réponse
-                return self._parse_response(response_content, current_time, current_location)
-            except Exception as e:
-                print(f"Error generating metadata: {str(e)}")
-                last_error = str(e)
-                retry_count += 1
-                if retry_count < max_retries:
-                    await asyncio.sleep(2 * retry_count)
-                    continue
-                raise e
+        """Génère les métadonnées basées sur le texte de l'histoire."""
+        messages = self.prompt.format_messages(
+            story_text=story_text,
+            current_time=current_time,
+            current_location=current_location,
+            story_beat=story_beat,
+            error_feedback=""
+        )
         
-        raise Exception(f"Failed to generate valid metadata after {max_retries} attempts") 
+        return await self.mistral_client.generate(
+            messages=messages,
+            custom_parser=self._custom_parser
+        ) 

server/core/story_orchestrator.py

@@ -0,0 +1,115 @@
+from typing import List
+from api.models import StoryResponse, Choice
+from services.mistral_client import MistralClient
+from core.state.game_state import GameState
+from core.generators.text_generator import TextGenerator
+from core.generators.image_generator import ImageGenerator
+from core.generators.metadata_generator import MetadataGenerator
+from core.constants import GameConfig
+
+class StoryOrchestrator:
+    """Coordonne les différents générateurs pour produire l'histoire."""
+    
+    def __init__(self, mistral_client: MistralClient):
+        self.text_generator = TextGenerator(mistral_client)
+        self.image_generator = ImageGenerator(mistral_client)
+        self.metadata_generator = MetadataGenerator(mistral_client)
+        
+    def _is_ending(self, game_state: GameState, metadata_response) -> bool:
+        """Détermine si c'est une fin de jeu."""
+        return (
+            game_state.is_radiation_death(metadata_response.radiation_increase) or
+            metadata_response.is_death or
+            metadata_response.is_victory
+        )
+        
+    async def _handle_ending(self, game_state: GameState, text_response, metadata_response) -> StoryResponse:
+        """Gère la génération d'une fin."""
+        # Déterminer le type de fin
+        ending_type = "victory" if metadata_response.is_victory else "death"
+        
+        # Regénérer le texte avec le contexte de fin
+        text_response = await self.text_generator.generate_ending(
+            ending_type=ending_type,
+            current_scene=text_response.story_text,
+            story_history=game_state.format_history()
+        )
+        
+        # Ne générer qu'une seule image pour la fin
+        prompts_response = await self.image_generator.generate(text_response.story_text)
+        if len(prompts_response.image_prompts) > 1:
+            prompts_response.image_prompts = [prompts_response.image_prompts[0]]
+            
+        return self._build_response(
+            game_state=game_state,
+            text_response=text_response,
+            metadata_response=metadata_response,
+            image_prompts=prompts_response.image_prompts,
+            is_ending=True
+        )
+        
+    def _build_response(self, game_state: GameState, text_response, metadata_response, image_prompts: List[str], is_ending: bool = False) -> StoryResponse:
+        """Construit la réponse finale."""
+        choices = [] if is_ending else [
+            Choice(id=i, text=choice_text)
+            for i, choice_text in enumerate(metadata_response.choices, 1)
+        ]
+        
+        # Formater les prompts d'images avec le style et les métadonnées
+        formatted_prompts = [
+            self.image_generator.format_prompt(
+                prompt=prompt,
+                time=metadata_response.time,
+                location=metadata_response.location
+            )
+            for prompt in image_prompts
+        ]
+        
+        return StoryResponse(
+            story_text=text_response.story_text,
+            choices=choices,
+            is_victory=metadata_response.is_victory,
+            is_death=metadata_response.is_death,
+            radiation_level=game_state.radiation_level,
+            radiation_increase=metadata_response.radiation_increase,
+            time=metadata_response.time,
+            location=metadata_response.location,
+            raw_choices=metadata_response.choices,
+            image_prompts=formatted_prompts,
+            is_first_step=(game_state.story_beat == GameConfig.STORY_BEAT_INTRO)
+        )
+        
+    async def generate_story_segment(self, game_state: GameState, previous_choice: str) -> StoryResponse:
+        """Génère un segment complet de l'histoire."""
+        # 1. Générer le texte de l'histoire
+        text_response = await self.text_generator.generate(
+            story_beat=game_state.story_beat,
+            radiation_level=game_state.radiation_level,
+            current_time=game_state.current_time,
+            current_location=game_state.current_location,
+            previous_choice=previous_choice,
+            story_history=game_state.format_history()
+        )
+        
+        # 2. Générer les métadonnées
+        metadata_response = await self.metadata_generator.generate(
+            story_text=text_response.story_text,
+            current_time=game_state.current_time,
+            current_location=game_state.current_location,
+            story_beat=game_state.story_beat
+        )
+        
+        # 3. Vérifier si c'est une fin
+        if self._is_ending(game_state, metadata_response):
+            return await self._handle_ending(game_state, text_response, metadata_response)
+            
+        # 4. Générer les prompts d'images
+        prompts_response = await self.image_generator.generate(text_response.story_text)
+        
+        # 5. Construire et retourner la réponse
+        return self._build_response(
+            game_state=game_state,
+            text_response=text_response,
+            metadata_response=metadata_response,
+            image_prompts=prompts_response.image_prompts
+        ) 

server/core/styles/comic_styles.json

@@ -0,0 +1,259 @@
+{
+  "styles": [
+    {
+      "name": "Franco-Belge Ligne Claire",
+      "description": "Style épuré avec des lignes nettes et des couleurs plates",
+      "references": [
+        {
+          "artist": "Hergé",
+          "works": ["Tintin", "Les Aventures de Jo, Zette et Jocko"]
+        },
+        {
+          "artist": "Edgar P. Jacobs",
+          "works": ["Blake et Mortimer"]
+        },
+        {
+          "artist": "Yves Chaland",
+          "works": ["Freddy Lombard", "Bob Fish"]
+        },
+        {
+          "artist": "Joost Swarte",
+          "works": ["Modern Art", "L'Art Moderne"]
+        }
+      ]
+    },
+    {
+      "name": "Science-Fiction Européenne",
+      "description": "Style visionnaire mêlant précision technique et onirisme",
+      "references": [
+        {
+          "artist": "Moebius (Jean Giraud)",
+          "works": ["L'Incal", "Arzak", "Le Garage Hermétique", "Aedena"]
+        },
+        {
+          "artist": "Philippe Druillet",
+          "works": ["Lone Sloane", "Salammbô", "Delirius"]
+        },
+        {
+          "artist": "François Schuiten",
+          "works": ["Les Cités Obscures", "La Fièvre d'Urbicande"]
+        }
+      ]
+    },
+    {
+      "name": "Comics Américain Classique",
+      "description": "Style dynamique avec des couleurs vives et des ombrages marqués",
+      "references": [
+        {
+          "artist": "Jack Kirby",
+          "works": ["Fantastic Four", "New Gods", "Captain America"]
+        },
+        {
+          "artist": "Steve Ditko",
+          "works": ["Spider-Man", "Doctor Strange", "Mr. A"]
+        },
+        {
+          "artist": "Neal Adams",
+          "works": ["Batman", "Green Lantern/Green Arrow", "X-Men"]
+        },
+        {
+          "artist": "John Buscema",
+          "works": ["Conan the Barbarian", "Silver Surfer", "The Avengers"]
+        }
+      ]
+    },
+    {
+      "name": "Comics Moderne",
+      "description": "Style contemporain avec techniques mixtes et mise en page innovante",
+      "references": [
+        {
+          "artist": "Alex Ross",
+          "works": ["Kingdom Come", "Marvels", "Justice"]
+        },
+        {
+          "artist": "J.H. Williams III",
+          "works": ["Promethea", "Batwoman", "The Sandman: Overture"]
+        },
+        {
+          "artist": "Sean Murphy",
+          "works": ["Batman: White Knight", "Tokyo Ghost", "Punk Rock Jesus"]
+        }
+      ]
+    },
+    {
+      "name": "Manga Seinen",
+      "description": "Style mature avec des détails complexes et des contrastes forts",
+      "references": [
+        {
+          "artist": "Katsuhiro Otomo",
+          "works": ["Akira", "Domu", "Memories"]
+        },
+        {
+          "artist": "Tsutomu Nihei",
+          "works": ["Blame!", "Knights of Sidonia", "Biomega"]
+        },
+        {
+          "artist": "Takehiko Inoue",
+          "works": ["Vagabond", "Real", "Slam Dunk"]
+        },
+        {
+          "artist": "Naoki Urasawa",
+          "works": ["Monster", "20th Century Boys", "Pluto"]
+        }
+      ]
+    },
+    {
+      "name": "Manga Horror",
+      "description": "Style détaillé avec emphase sur l'horreur psychologique et corporelle",
+      "references": [
+        {
+          "artist": "Junji Ito",
+          "works": ["Uzumaki", "Tomie", "Gyo"]
+        },
+        {
+          "artist": "Suehiro Maruo",
+          "works": [
+            "Mr. Arashi's Amazing Freak Show",
+            "The Strange Tale of Panorama Island"
+          ]
+        },
+        {
+          "artist": "Hideshi Hino",
+          "works": ["Hell Baby", "Panorama of Hell"]
+        }
+      ]
+    },
+    {
+      "name": "BD Alternative",
+      "description": "Style expressif avec des techniques mixtes et une approche artistique unique",
+      "references": [
+        {
+          "artist": "Dave McKean",
+          "works": ["Arkham Asylum", "Signal to Noise", "Cages"]
+        },
+        {
+          "artist": "Bill Sienkiewicz",
+          "works": ["Elektra: Assassin", "Stray Toasters", "New Mutants"]
+        },
+        {
+          "artist": "Lorenzo Mattotti",
+          "works": ["Feux", "Le Bruit du givre", "Stigmates"]
+        },
+        {
+          "artist": "Kent Williams",
+          "works": ["Tell Me, Dark", "The Fountain", "Blood: A Tale"]
+        }
+      ]
+    },
+    {
+      "name": "Noir et Blanc Expressionniste",
+      "description": "Style contrasté avec des noirs profonds et des blancs éclatants",
+      "references": [
+        {
+          "artist": "Frank Miller",
+          "works": ["Sin City", "300", "Ronin"]
+        },
+        {
+          "artist": "Alberto Breccia",
+          "works": ["Mort Cinder", "Perramus", "Los Mitos de Cthulhu"]
+        },
+        {
+          "artist": "Jacques Tardi",
+          "works": [
+            "C'était la guerre des tranchées",
+            "Le Cri du peuple",
+            "Adèle Blanc-Sec"
+          ]
+        },
+        {
+          "artist": "José Muñoz",
+          "works": ["Alack Sinner", "Le Bar à Joe"]
+        }
+      ]
+    },
+    {
+      "name": "Style Numérique Moderne",
+      "description": "Style contemporain utilisant les techniques digitales",
+      "references": [
+        {
+          "artist": "Bastien Vivès",
+          "works": ["Polina", "Le Goût du chlore", "Une sœur"]
+        },
+        {
+          "artist": "Bengal",
+          "works": ["Naja", "Luminae", "Death or Glory"]
+        },
+        {
+          "artist": "Claire Wendling",
+          "works": ["Les Lumières de l'Amalou", "Desk", "Iguana Bay"]
+        },
+        {
+          "artist": "Boulet",
+          "works": ["Notes", "La Page Blanche"]
+        }
+      ]
+    },
+    {
+      "name": "Post-Apocalyptique",
+      "description": "Style rugueux avec des atmosphères sombres et des environnements dévastés",
+      "references": [
+        {
+          "artist": "Enki Bilal",
+          "works": ["La Trilogie Nikopol", "Animal'z", "Bug"]
+        },
+        {
+          "artist": "Juan Giménez",
+          "works": [
+            "La Caste des Méta-Barons",
+            "Le Quatrième Pouvoir",
+            "Leo Roa"
+          ]
+        },
+        {
+          "artist": "Geof Darrow",
+          "works": ["Hard Boiled", "Shaolin Cowboy", "Big Guy and Rusty"]
+        },
+        {
+          "artist": "Simon Bisley",
+          "works": ["Slaine", "Lobo", "Heavy Metal"]
+        }
+      ]
+    },
+    {
+      "name": "Underground Américain",
+      "description": "Style brut et provocateur avec une approche contre-culturelle",
+      "references": [
+        {
+          "artist": "Robert Crumb",
+          "works": ["Zap Comix", "Fritz the Cat", "Mr. Natural"]
+        },
+        {
+          "artist": "Spain Rodriguez",
+          "works": ["Trashman", "Mean Bitch Thrills"]
+        },
+        {
+          "artist": "Gilbert Shelton",
+          "works": ["The Fabulous Furry Freak Brothers", "Wonder Wart-Hog"]
+        }
+      ]
+    },
+    {
+      "name": "Nouveau Roman Graphique",
+      "description": "Style intimiste avec une approche narrative personnelle",
+      "references": [
+        {
+          "artist": "Chris Ware",
+          "works": ["Jimmy Corrigan", "Building Stories", "Rusty Brown"]
+        },
+        {
+          "artist": "Daniel Clowes",
+          "works": ["Ghost World", "David Boring", "Patience"]
+        },
+        {
+          "artist": "Adrian Tomine",
+          "works": ["Killing and Dying", "Shortcomings", "Optic Nerve"]
+        }
+      ]
+    }
+  ]
+}

server/scripts/test_game.py

@@ -122,10 +122,10 @@ async def play_game(show_context: bool = False):
             # Get player choice
             while True:
                 try:
-                    last_choice = int(input("\n👉 Your choice (1-2): "))
-                    if 1 <= last_choice <= 2:
+                    last_choice = int(input(f"\n👉 Your choice (1-{len(response.choices)}): "))
+                    if 1 <= last_choice <= len(response.choices):
                         break
-                    print("❌ Invalid choice. Please choose 1 or 2.")
+                    print(f"❌ Invalid choice. Please choose between 1 and {len(response.choices)}.")
                 except ValueError:
                     print("❌ Please enter a number.")
             

server/server.py

@@ -33,7 +33,8 @@ app.add_middleware(
         "http://localhost:5173",
         f"http://localhost:{API_PORT}",
         "https://huggingface.co",
-        "https://*.hf.space"
+        "https://*.hf.space",
+        "https://mistral-ai-game-jam-dont-lookup.hf.space"
     ],
     allow_credentials=True,
     allow_methods=["*"],

server/services/mistral_client.py

@@ -1,8 +1,13 @@
 import asyncio
+import json
+from typing import TypeVar, Type, Optional, Callable
+from pydantic import BaseModel
 from langchain_mistralai.chat_models import ChatMistralAI
 from langchain.schema import SystemMessage, HumanMessage
 from langchain.schema.messages import BaseMessage
 
+T = TypeVar('T', bound=BaseModel)
+
 # Available Mistral models:
 # - mistral-tiny     : Fastest, cheapest, good for testing
 # - mistral-small    : Good balance of speed and quality
@@ -36,6 +41,7 @@ class MistralClient:
         # Pour gérer le rate limit
         self.last_call_time = 0
         self.min_delay = 1  # 1 seconde minimum entre les appels
+        self.max_retries = 3
     
     async def _wait_for_rate_limit(self):
         """Attend le temps nécessaire pour respecter le rate limit."""
@@ -46,29 +52,80 @@ class MistralClient:
             await asyncio.sleep(self.min_delay - time_since_last_call)
         
         self.last_call_time = asyncio.get_event_loop().time()
+
+    async def _generate_with_retry(
+        self,
+        messages: list[BaseMessage],
+        response_model: Optional[Type[T]] = None,
+        custom_parser: Optional[Callable[[str], T]] = None,
+        error_feedback: str = None
+    ) -> T | str:
+        """
+        Génère une réponse avec retry et parsing structuré optionnel.
+        
+        Args:
+            messages: Liste des messages pour le modèle
+            response_model: Classe Pydantic pour parser la réponse
+            custom_parser: Fonction de parsing personnalisée
+            error_feedback: Feedback d'erreur à ajouter au prompt en cas de retry
+        """
+        retry_count = 0
+        last_error = None
+        
+        while retry_count < self.max_retries:
+            try:
+                # Ajouter le feedback d'erreur si présent
+                current_messages = messages.copy()
+                if error_feedback and retry_count > 0:
+                    current_messages.append(HumanMessage(content=f"Previous error: {error_feedback}. Please try again."))
+                
+                # Générer la réponse
+                await self._wait_for_rate_limit()
+                response = await self.model.ainvoke(current_messages)
+                content = response.content
+                
+                # Si pas de parsing requis, retourner le contenu brut
+                if not response_model and not custom_parser:
+                    return content
+                
+                # Parser la réponse
+                if custom_parser:
+                    return custom_parser(content)
+                
+                # Essayer de parser avec le modèle Pydantic
+                try:
+                    data = json.loads(content)
+                    return response_model(**data)
+                except json.JSONDecodeError as e:
+                    last_error = f"Invalid JSON format: {str(e)}"
+                    raise ValueError(last_error)
+                except Exception as e:
+                    last_error = str(e)
+                    raise ValueError(last_error)
+                
+            except Exception as e:
+                print(f"Error on attempt {retry_count + 1}/{self.max_retries}: {str(e)}")
+                retry_count += 1
+                if retry_count < self.max_retries:
+                    await asyncio.sleep(2 * retry_count)
+                    continue
+                raise Exception(f"Failed after {self.max_retries} attempts. Last error: {last_error or str(e)}")
     
-    async def generate_story(self, messages: list[BaseMessage]) -> str:
-        """Génère une réponse à partir d'une liste de messages."""
-        try:
-            await self._wait_for_rate_limit()
-            response = await self.model.ainvoke(messages)
-            return response.content
-        except Exception as e:
-            print(f"Error in Mistral API call: {str(e)}")
-            raise
+    async def generate(self, messages: list[BaseMessage], response_model: Optional[Type[T]] = None, custom_parser: Optional[Callable[[str], T]] = None) -> T | str:
+        """Génère une réponse à partir d'une liste de messages avec parsing optionnel."""
+        return await self._generate_with_retry(messages, response_model, custom_parser)
 
     async def transform_prompt(self, story_text: str, art_prompt: str) -> str:
         """Transforme un texte d'histoire en prompt artistique."""
+        messages = [{
+            "role": "system",
+            "content": art_prompt
+        }, {
+            "role": "user",
+            "content": f"Transform this story text into a comic panel description:\n{story_text}"
+        }]
         try:
-            await self._wait_for_rate_limit()
-            response = await self.model.ainvoke([{
-                "role": "system",
-                "content": art_prompt
-            }, {
-                "role": "user",
-                "content": f"Transform this story text into a comic panel description:\n{story_text}"
-            }])
-            return response.content
+            return await self._generate_with_retry(messages)
         except Exception as e:
             print(f"Error transforming prompt: {str(e)}")
             return story_text