Update app.py

app.py

@@ -1,802 +1,682 @@
 import gradio as gr
-from gradio_client import Client
-
 from openai import OpenAI
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 import os
 import requests
 from PIL import Image
 import tempfile
 import numpy as np
-
 import markdown
 import base64
+import datetime
+import json
+from dotenv import load_dotenv
 
+# --- Configuration ---
+load_dotenv() # Charge les variables depuis un fichier .env s'il existe
 
-# Modèle pour la réponse de l'analyse des biais
-class BiasAnalysisResponse(BaseModel):
-    biases: list[str]
-    advice: list[str]
-
-# Fonction pour définir la clé API
-def set_openai_api_key(api_key):
-    if (api_key):
-        os.environ["OPENAI_API_KEY"] = api_key
-        global client
-        client = OpenAI(api_key=api_key)
-        return "Clé API définie avec succès !"
-    else:
-        return "La clé API est requise !"
+api_key = os.getenv("OPENROUTER_API_KEY")
+
+if not api_key:
+    print("ERREUR: Clé API OpenRouter non trouvée. Définissez OPENROUTER_API_KEY dans l'environnement ou le fichier .env.")
+    # Mettre ici une gestion d'erreur plus propre si besoin
+
+# Initialisation du client OpenAI pour pointer vers OpenRouter
+client = OpenAI(
+    base_url="https://openrouter.ai/api/v1",
+    api_key=api_key,
+)
 
-# Fonction pour analyser les biais dans le texte de l'objectif
-def analyze_biases(objective_text):
+# --- Modèles Pydantic pour la structuration ---
+
+class BiasInfo(BaseModel):
+    bias_type: str = Field(..., description="Type de biais identifié (ex: Stéréotype de genre, Biais de confirmation)")
+    explanation: str = Field(..., description="Explication de pourquoi cela pourrait être un biais dans ce contexte.")
+    advice: str = Field(..., description="Conseil spécifique pour atténuer ce biais.")
+
+class BiasAnalysisResponse(BaseModel):
+    detected_biases: list[BiasInfo] = Field(default_factory=list, description="Liste des biais potentiels détectés.")
+    overall_comment: str = Field(default="", description="Commentaire général ou indication si aucun biais majeur n'est détecté.")
+
+
+# --- Fonctions Utilitaires ---
+
+# Dictionnaires de correspondance (conservés de V1)
+posture_mapping = {"": "","Debout": "standing up","Assis": "sitting","Allongé": "lying down","Accroupi": "crouching","En mouvement": "moving","Reposé": "resting"}
+facial_expression_mapping = {"": "","Souriant": "smiling","Sérieux": "serious","Triste": "sad","En colère": "angry","Surpris": "surprised","Pensif": "thoughtful"}
+skin_color_mapping = {"": "","Clair": "light","Moyen": "medium","Foncé": "dark","Très foncé": "very dark"}
+eye_color_mapping = {"": "","Bleu": "blue","Vert": "green","Marron": "brown","Gris": "gray"}
+hair_style_mapping = {"": "","Court": "short","Long": "long","Bouclé": "curly","Rasé": "shaved","Chauve": "bald","Tresses": "braided","Queue de cheval": "ponytail","Coiffure afro": "afro","Dégradé": "fade"}
+hair_color_mapping = {"": "","Blond": "blonde","Brun": "brown","Noir": "black","Roux": "red","Gris": "gray","Blanc": "white"}
+clothing_style_mapping = {"": "","Décontracté": "casual","Professionnel": "professional","Sportif": "sporty"}
+accessories_mapping = {"": "","Lunettes": "glasses","Montre": "watch","Chapeau": "hat"}
+
+# Fonction de mise à jour du journal
+def update_log(event_description, session_log_state):
+    timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    new_log_entry = f"[{timestamp}] {event_description}"
+    current_log = session_log_state.value if session_log_state.value else ""
+    # Limiter la taille du log si nécessaire pour éviter des problèmes de performance
+    log_lines = current_log.splitlines()
+    if len(log_lines) > 100: # Garde les 100 dernières lignes par exemple
+         current_log = "\n".join(log_lines[-100:])
+    updated_log = current_log + new_log_entry + "\n"
+    session_log_state.value = updated_log
+    return updated_log
+
+# --- Fonctions Principales de l'Application ---
+
+def analyze_biases_v2(objective_text, session_log_state):
+    """Analyse les biais dans l'objectif marketing (V2 avec prompt ciblé)."""
+    log_event_start = f"Analyse Biais Objectif (début): '{objective_text[:50]}...'"
+    update_log(log_event_start, session_log_state)
+
+    # Prompt système V2 (catégories + exemples)
+    system_prompt = f"""
+    Tu es un expert en marketing éthique et en psychologie cognitive, spécialisé dans la création de personas.
+    Analyse l'objectif marketing suivant : "{objective_text}"
+
+    Identifie les BIAIS COGNITIFS POTENTIELS ou RISQUES DE STÉRÉOTYPES pertinents pour la création de personas. Concentre-toi sur :
+    1.  **Stéréotypes / Généralisations Hâtives :** Suppose-t-on des traits basés sur le genre, l'âge, l'ethnie, le statut socio-économique sans justification ? (Ex: 'tous les jeunes urbains sont écolos')
+    2.  **Biais de Confirmation / Affinité :** L'objectif semble-t-il chercher à valider une idée préconçue ou refléter trop les opinions du concepteur ? (Ex: 'prouver que notre produit est parfait pour CE type de personne')
+    3.  **Simplification Excessive / Manque de Nuance :** Le groupe cible est-il décrit de manière trop monolithique, ignorant la diversité interne ? (Ex: 'les seniors actifs' sans différencier leurs motivations ou capacités)
+    4.  **Autres biais pertinents** (Ex: Oubli de fréquence de base, Biais de normalité si applicable).
+
+    Pour chaque biais potentiel identifié :
+    - Nomme le type de biais (ex: Stéréotype d'âge).
+    - Explique brièvement POURQUOI c'est un risque DANS CE CONTEXTE de création de persona.
+    - Propose un CONSEIL PRÉCIS pour nuancer l'objectif ou être vigilant lors de la création.
+
+    Structure ta réponse en utilisant le format JSON suivant (avec la classe Pydantic BiasAnalysisResponse):
+    {{
+        "detected_biases": [
+            {{
+                "bias_type": "Type de biais identifié",
+                "explanation": "Explication contextuelle du risque.",
+                "advice": "Conseil spécifique d'atténuation."
+            }}
+        ],
+        "overall_comment": "Bref commentaire général. Indique si aucun biais majeur n'est détecté."
+    }}
+    Réponds en français. S'il n'y a pas de biais clair, retourne une liste 'detected_biases' vide et indique-le dans 'overall_comment'.
+    """
     try:
-        system__prompt = f"""
-        Le texte est écrit par un professionnel du marketing qui essaie de créer un persona.
-        Analysez le texte suivant à la recherche de biais cognitifs potentiels et donnez des conseils sur la manière de les atténuer.
-        Répondez dans le même langage de l'utilisateur.
-        Liste de biais cognitifs
-
-        Biais attentionnels
-        Biais d'attention — avoir ses perceptions influencées par ses propres centres d’intérêt.
-
-        Biais mnésique
-        Biais de négativité — également connu sous le nom d'effet de négativité, est la notion que, même à intensité égale, les choses de nature plus négative ont un effet plus important sur l'état et les processus psychologiques que les choses neutres ou positives.
-        Effet de récence — mieux se souvenir des dernières informations auxquelles on a été confronté.
-        Effet de simple exposition — avoir préalablement été exposé à une personne ou à une situation la rend plus positive.
-        Effet de primauté — mieux se souvenir des premiers éléments d'une liste mémorisée.
-        Oubli de la fréquence de base — oublier de considérer la fréquence de base de l'occurrence d'un événement alors qu'on cherche à en évaluer une probabilité.
-        
-        Biais de jugement
-        Appel à la probabilité — tendance à prendre quelque chose pour vrai parce que cela peut probablement être le cas.
-        Appel à la tradition — tendance à considérer que l’ancienneté d’une théorie ou d’une assertion étaye sa véracité.
-        Aversion à la dépossession — tendance à donner plus de valeur à un bien ou un service lorsque celui-ci est sa propriété.
-        Biais d'ancrage — influence laissée par la première impression.
-        Biais d'attribution (attribution causale) — façon d'attribuer la responsabilité d'une situation à soi ou aux autres.
-        
-        Biais d'attribution hostile
-        Biais d'auto-complaisance — se croire à l'origine de ses réussites, mais pas de ses échecs.
-        Biais d'engagement — tendance à poursuivre l'action engagée malgré la confrontation à des résultats de plus en plus négatifs.
-        Biais d'équiprobabilité — tendance à penser qu'en l'absence d'information, des évènements sont équiprobables.
-        Biais d'immunité à l'erreur — ne pas voir ses propres erreurs.
-        Biais d'intentionnalité — consiste à percevoir l'action d'une volonté ou d'une décision derrière ce qui est fortuit ou accidentel.
-        Biais de confirmation — tendance à valider ses opinions auprès des instances qui les confirment, et à rejeter d'emblée les instances qui les réfutent.
-        Biais de normalité — tendance à penser que tout va se passer comme d'habitude et à ignorer les signes avant-coureurs6.
-        Biais de présentéisme — privilégier les facteurs présents est plus économique cognitivement à modéliser que les facteurs absents.
-        Biais de proportionnalité — favoriser l'idée potentiellement fausse que si l'on observe une augmentation des manifestations d'un phénomène, c'est que le nombre d'occurrences de ce phénomène croît en effet, sans voir que cette augmentation peut n'être que la conséquence de l'amélioration de l'outil d'observation.
-        Biais de statu quo — la nouveauté est vue comme apportant plus de risques que d'avantages possibles et amène une résistance au changement.
-        Biais égocentrique — se juger sous un meilleur jour qu'en réalité.
-        Biais rétrospectif ou l'effet « je le savais depuis le début » — tendance à juger a posteriori qu'un événement était prévisible.
-        Corrélation illusoire — perception d'une corrélation entre deux événements qui n'existe pas ou qui est bien plus faible en réalité.
-        Croyance en un monde juste — tendance à considérer que la bonne action d'une personne lui sera nécessairement bénéfique tandis qu'une mauvaise action lui sera nécessairement néfaste.
-        Effet d'ambiguïté — tendance à éviter les options pour lesquelles on manque d'information.
-        Effet de halo — une perception sélective d'informations allant dans le sens d'une première impression que l'on cherche à confirmer.
-        Effet de simple exposition — avoir préalablement été exposé à quelqu'un ou à une situation le/la rend plus positive.
-        Effet Dunning-Kruger — les moins compétents dans un domaine surestiment leur compétence, alors que les plus compétents ont tendance à sous-estimer leur compétence.
-        Effet Ikea — tendance pour les consommateurs à accorder une valeur supérieure aux produits qu'ils ont partiellement créés.
-        Effet moins-c'est-mieux — tendance à effectuer un choix a priori moins avantageux objectivement (par exemple apprécier plus une coupe de glace de moindre quantité mais mieux remplie).
-        Effet Stroop — incapacité d'ignorer une information non pertinente.
-        Effet râteau — exagérer la régularité du hasard.
-        Illusion de fréquence — tendance, après avoir remarqué une chose pour la première fois, à la remarquer plus souvent et à la croire plus fréquente.
-        Erreur fondamentale d'attribution (ou biais d'internalité) — accorder plus d'importance aux facteurs internes à l'orateur (intentions, émotions) qu'à son discours ou à ses actes (faits tangibles). Couramment utilisé pour discréditer les éléments rationnels par des éléments émotionnels, qui sont en pratique souvent imaginés et attribués sans preuve à l'orateur puisque ses émotions internes sont difficilement discernables a priori.[réf. nécessaire]
-        Illusion de savoir — dans une situation en apparence identique à une situation commune, réagir de manière habituelle, sans éprouver le besoin de rechercher les informations complémentaires qui auraient mis en évidence une différence par rapport à la situation habituelle. Il peut ainsi faire état d'une mauvaise croyance face à la réalité.
-        Illusion monétaire — confusion d'un agent économique entre variation du niveau général des prix et variation des prix relatifs.
-        Illusion de transparence et illusion de connaissance asymétrique.
-        Loi de l'instrument (ou marteau de Maslow) — tentation qui consiste à travestir la réalité d'un problème en le transformant en fonction des réponses (les outils) dont on dispose.
-        Sophisme génétique — tendance à juger le contenu en fonction du contenant, le message en fonction du messager, le fond suivant la forme.
-        Supériorité illusoire — surestimation de ses propres qualités et capacités.
-        Tache aveugle à l'égard des préjugés — tendance à ne pas percevoir les biais cognitifs à l'œuvre dans ses propres jugements ou décisions, et ce, aux dépens d'informations plus objectives.
-        
-        Biais de raisonnement
-        Biais de confirmation d'hypothèse — préférer les éléments qui confirment plutôt que ceux qui infirment une hypothèse.
-        Biais d'évaluation de probabilités.
-        Biais de représentativité — considérer un ou certains éléments comme représentatifs d'une population.
-        Biais de disponibilité — ne pas chercher d'autres informations que celles immédiatement disponibles.
-        Biais d'appariement — se focaliser sur les éléments contenus dans l'énoncé d'un problème.
-        Biais du survivant — se focaliser sur les éléments ayant passé avec succès un processus de sélection pour en tirer des conclusions sur la totalité des éléments.
-        Réduction de la dissonance cognitive — réinterpréter une situation pour éliminer les contradictions.
-        Effet rebond (assimilable à l'effet Streisand) — une pensée que l'on cherche à inhiber devient plus saillante.
-        Illusion des séries — percevoir à tort des coïncidences dans des données au hasard.
-        Perception sélective — interpréter de manière sélective des informations en fonction de sa propre expérience.
-        Réification du savoir — considérer les connaissances comme des objets immuables et extérieurs.
-        Effet de domination asymétrique ou effet leurre — choisir pour un consommateur entre deux options celle qui est la plus proche d'une troisième option malgré la forte asymétrie d'information.
-        Coût irrécupérable — considérer les coûts déjà engagés dans une décision.
-        Oubli de la fréquence de base — oublier la fréquence de base de l'occurrence d'un événement dont on cherche à évaluer la probabilité.
-        
-        Biais liés à la personnalité
-        Biais d'optimisme — optimisme dispositionnel7, optimisme irréaliste8, parfois présenté comme un « non-pessimisme dispositionnel »9 et d'optimisme comparatif10,11 qui semble très ancrée chez l'être humain ; il s'agit d'une croyance individuelle qui est que le sujet se juge moins exposé à la plupart des risques qu'autrui12,13. On peut évaluer le degré d'adhésion à cette croyance en demandant au sujet d’évaluer son risque de rencontrer un événement négatif en comparaison de celui d’autrui13. Cette croyance aggrave certaines prises de risques et est souvent impliquée dans l'accidentologie routière (le conducteur s'estimant à tort plus habile que les autres pour éviter les accidents, même quand il ne respecte pas le code de la route, en raison d'une surestimation infondée et irréaliste de ses capacités)14,15,16,17.
-        Effet Barnum — accepter une vague description de la personnalité comme s'appliquant spécifiquement à soi-même (ex. : horoscope).
-
-        S'il n'y a pas de biais, respectez le format demandé et indiquez qu'aucun biais n'a été détecté.
-        """
-
-        completion = client.beta.chat.completions.parse(
-            model="gpt-4o-mini",
+        completion = client.chat.completions.create(
+            model=MODEL_NAME,
             messages=[
-                {"role": "system", "content": system__prompt},
-                {"role": "user", "content": objective_text}
+                {"role": "user", "content": system_prompt} # Intégration de l'objectif dans le prompt système peut être plus robuste pour certains modèles
             ],
-            temperature=0.5,
+            temperature=0.4,
             max_tokens=800,
-            response_format=BiasAnalysisResponse
+            response_format={"type": "json_object"}, # Demander explicitement du JSON si le modèle le supporte bien
         )
-        
-        # Obtenir la réponse structurée
-        response_content = completion.choices[0].message.parsed
-        return response_content.dict()
 
-    except Exception as e:
-        print("Error during bias analysis:", str(e))
-        return {"error": str(e)}
-
-# Optimiser la génération d'image pour utiliser directement l'URL
-def generate_persona_image(first_name, last_name, age, gender, persona_description,
-                           skin_color, eye_color, hair_style, hair_color, facial_expression,
-                           posture, clothing_style, accessories):
-    if not first_name or not last_name or not age or not gender:
-        return gr.Info("Veuillez remplir tous les champs pour générer l'image du persona.")
-    
-    prompt = f"one person. {first_name} {last_name}, {gender}, {age} years old. Realist photo."
-    
-    # Ajouter les nouvelles informations au prompt
-    if skin_color:
-        skin_color_eng = skin_color_mapping.get(skin_color, skin_color)
-        prompt += f" Skin tone: {skin_color_eng}."
-    if eye_color:
-        eye_color_eng = eye_color_mapping.get(eye_color, eye_color)
-        prompt += f" Eye color: {eye_color_eng}."
-    if hair_style:
-        hair_style_eng = hair_style_mapping.get(hair_style, hair_style)
-        prompt += f" Hairstyle: {hair_style_eng}."
-    if hair_color:
-        hair_color_eng = hair_color_mapping.get(hair_color, hair_color)
-        prompt += f" Hair color: {hair_color_eng}."
-    if facial_expression:
-        facial_expression_eng = facial_expression_mapping.get(facial_expression, facial_expression)
-        prompt += f" Facial expression: {facial_expression_eng}."
-    if posture:
-        posture_eng = posture_mapping.get(posture, posture)
-        prompt += f" Posture: {posture_eng}."
-    if clothing_style:
-        clothing_style_eng = clothing_style_mapping.get(clothing_style, clothing_style)
-        prompt += f" Clothing style: {clothing_style_eng}."
-    if accessories:
-        accessories_eng = accessories_mapping.get(accessories, accessories)
-        prompt += f" Accessories: {accessories_eng}."
-    
-    prompt += f" {persona_description}."
-    
-    response = client.images.generate(
-        model="dall-e-3",
-        prompt=prompt,
-        size="1024x1024",
-        n=1,
-    )
-    image_url = response.data[0].url
-    response_image = requests.get(image_url)
-    temp_image = tempfile.NamedTemporaryFile(delete=False, suffix='.png')
-    with open(temp_image.name, 'wb') as f:
-        f.write(response_image.content)
-
-    global temp_image_path
-    temp_image_path = temp_image.name
-
-    return temp_image.name  # Retourner le chemin local de l'image
-
-# Ajouter les dictionnaires de correspondance
-posture_mapping = {
-    "": "",
-    "Debout": "standing up",
-    "Assis": "sitting",
-    "Allongé": "lying down",
-    "Accroupi": "crouching",
-    "En mouvement": "moving",
-    "Reposé": "resting"
-}
-
-facial_expression_mapping = {
-    "": "",
-    "Souriant": "smiling",
-    "Sérieux": "serious",
-    "Triste": "sad",
-    "En colère": "angry",
-    "Surpris": "surprised",
-    "Pensif": "thoughtful"
-}
-
-skin_color_mapping = {
-    "": "",
-    "Clair": "light",
-    "Moyen": "medium",
-    "Foncé": "dark",
-    "Très foncé": "very dark"
-}
-
-eye_color_mapping = {
-    "": "",
-    "Bleu": "blue",
-    "Vert": "green",
-    "Marron": "brown",
-    "Gris": "gray"
-}
-
-hair_style_mapping = {
-    "": "",
-    "Court": "short",
-    "Long": "long",
-    "Bouclé": "curly",
-    "Rasé": "shaved",
-    "Chauve": "bald",
-    "Tresses": "braided",
-    "Queue de cheval": "ponytail",
-    "Coiffure afro": "afro",
-    "Dégradé": "fade"
-}
-
-hair_color_mapping = {
-    "": "",
-    "Blond": "blonde",
-    "Brun": "brown",
-    "Noir": "black",
-    "Roux": "red",
-    "Gris": "gray",
-    "Blanc": "white"
-}
-
-clothing_style_mapping = {
-    "": "",
-    "Décontracté": "casual",
-    "Professionnel": "professional",
-    "Sportif": "sporty"
-}
-
-accessories_mapping = {
-    "": "",
-    "Lunettes": "glasses",
-    "Montre": "watch",
-    "Chapeau": "hat"
-}
-
-# Fonction pour affiner les contributions de l'utilisateur et de l'IA
-def refine_persona_details(first_name, last_name, age, field_name, field_value, biases, marketing_objectives):
-    system_prompt = f"""
-    Vous êtes un assistant IA aidant à affiner les détails d'un persona marketing.
-    Ne traitez que le champ suivant : {field_name}.
-    Basé sur les informations fournies, proposez des suggestions pour améliorer le profil du persona.
-    S'il n'y a pas d'informations spécifiques, indiquez qu'il faut plus de détails.
-    Soyez extrêmement concis et clair.
-
-    Informations du persona :
-    Nom : {first_name} {last_name}
-    Âge : {age}
+        response_content_str = completion.choices[0].message.content
+        # Essayer de parser la réponse JSON
+        parsed_response = BiasAnalysisResponse.parse_raw(response_content_str)
 
-    Objectifs marketing initiaux :
-    {marketing_objectives}
+        log_event_end = f"Analyse Biais Objectif (fin): Biais trouvés - {len(parsed_response.detected_biases)}"
+        update_log(log_event_end, session_log_state)
+        return parsed_response.dict(), update_log("", session_log_state) # Retourne dict et log mis à jour
 
-    Biais identifiés lors de la formulation de ces objectifs :
-    {biases}
+    except Exception as e:
+        error_msg = f"Erreur pendant l'analyse des biais: {str(e)}. Réponse brute: {response_content_str if 'response_content_str' in locals() else 'N/A'}"
+        print(error_msg)
+        update_log(f"ERREUR Analyse Biais: {str(e)}", session_log_state)
+        # Retourner une structure d'erreur compatible
+        error_response = BiasAnalysisResponse(overall_comment=f"Erreur technique lors de l'analyse: {str(e)}").dict()
+        return error_response, update_log("", session_log_state)
+
+def display_bias_analysis_v2(analysis_result):
+    """Formate l'analyse des biais pour l'affichage avec HighlightedText."""
+    if not analysis_result or "error" in analysis_result:
+        return [("Erreur ou pas de résultat.", None)], analysis_result # Retourne un format compatible HighlightedText
+
+    biases = analysis_result.get("detected_biases", [])
+    overall_comment = analysis_result.get("overall_comment", "")
+
+    highlighted_data = []
+    if not biases:
+        highlighted_data.append((overall_comment or "Aucun biais majeur détecté.", "INFO"))
+    else:
+         if overall_comment:
+             highlighted_data.append((overall_comment + "\n", "COMMENT"))
+         for bias_info in biases:
+             highlighted_data.append((f"⚠️ {bias_info['bias_type']}: ", "BIAS_TYPE"))
+             highlighted_data.append((f"{bias_info['explanation']} ", "EXPLANATION"))
+             highlighted_data.append((f"💡 Conseil: {bias_info['advice']}\n", "ADVICE"))
+
+    # Retourne les données formatées pour HighlightedText et le résultat brut pour usage ultérieur
+    return highlighted_data, analysis_result
+
+
+def generate_persona_image_v2(*args):
+    """Génère l'image du persona (V2 avec logging)."""
+    # Les 13 premiers args sont les inputs de l'image, le dernier est session_log_state
+    inputs = args[:-1]
+    session_log_state = args[-1]
+    (first_name, last_name, age, gender, persona_description,
+     skin_color, eye_color, hair_style, hair_color, facial_expression,
+     posture, clothing_style, accessories) = inputs
 
-    Étape actuelle : Affinage des détails du persona.
-    """
-    response = client.chat.completions.create(
-        model="gpt-4o-mini",
-        messages=[{"role": "system", "content": system_prompt},
-            {"role": "user", "content": f"""{field_name} : {field_value}"""}],
-        temperature=0.2,
-        max_tokens=150,
-    )
-    suggestions = response.choices[0].message.content.strip()
-    suggestions_html = markdown.markdown(suggestions)
-    gr.Info(suggestions_html, duration=60)
-
-with gr.Blocks(theme=gr.themes.Citrus()) as demo:
-    gr.Markdown("# Assistant de création de persona")
-
-    with gr.Tab("Informations sur l'API OpenAI"):
-        gr.Markdown("### Informations sur l'API OpenAI")
-        gr.Markdown("Veuillez entrer votre clé API OpenAI pour commencer. [Voici un tutoriel pour vous aider à obtenir votre clé API](https://www.justgeek.fr/comment-obtenir-votre-cle-api-openai-107699/).")
-
-        # Section de connexion API
-        api_key_input = gr.Textbox(label="Entrez votre clé API OpenAI", type="password")
-        api_key_button = gr.Button("Définir la clé API")
-        api_key_status = gr.Textbox(label="Statut de la clé API", interactive=False)
-        api_key_button.click(fn=set_openai_api_key, inputs=api_key_input, outputs=api_key_status)
-
-    with gr.Tab("Étape 1: Objectif et analyse des biais"):
-        objective_input = gr.Textbox(label="Quel est votre objectif pour la création de ce persona ?", lines=3)
-        analyze_button = gr.Button("Analyser les biais")
-        bias_analysis_output = gr.Markdown()
-        word_count_state = gr.State(0)  # Ajout d'un état pour le nombre de mots
-        realtime_analysis = gr.Radio(label="Analyse en temps réel", choices=["Activée", "Désactivée"], value="Désactivée")
-        word_count_display = gr.Markdown()  # Ajout d'un affichage pour le compteur de mots
-
-        # Définir les scénarios de suggestion
-        suggestion1 = "Je souhaite créer un persona pour promouvoir un nouveau service de livraison écologique destiné aux jeunes professionnels urbains soucieux de l'environnement. Nous avons réalisé une étude de marché et identifié un besoin pour des solutions de livraison plus durables et rapides. Pour cela, nous voulons créer un persona qui incarne ces valeurs et besoins. Plus spécifiquement, nous ciblons les personnes âgées de 25 à 35 ans, vivant dans des zones urbaines, travaillant à temps plein et ayant un intérêt pour les questions environnementales."
-        suggestion2 = "J'envisage de développer une application mobile de fitness personnalisée pour les seniors actifs qui cherchent à maintenir une vie saine et sociale. L'application proposera des programmes d'entraînement adaptés aux besoins et aux capacités des seniors, ainsi que des fonctionnalités pour suivre les progrès et rester motivé. Le persona devrait refléter les besoins et les préférences des seniors actifs, en mettant l'accent sur la facilité d'utilisation, la convivialité et la personnalisation. Nous visons à créer une expérience positive et engageante pour les utilisateurs."
-
-        # Ajouter les boutons de suggestion
-        with gr.Row():
-            suggestion_button1 = gr.Button("Suggestion 1")
-            suggestion_button2 = gr.Button("Suggestion 2")
-
-        # Définir les actions des boutons pour remplir le champ objective_input
-        suggestion_button1.click(fn=lambda: suggestion1, inputs=[], outputs=objective_input)
-        suggestion_button2.click(fn=lambda: suggestion2, inputs=[], outputs=objective_input)
-
-        # Fonction pour afficher dynamiquement les biais et les conseils
-        def display_biases_and_advice(objective_text, previous_count, realtime):
-            current_count = len(objective_text.split())
-            if realtime == "Activée" and current_count - previous_count >= 10:
-                analysis_result = analyze_biases(objective_text)
-                if "error" in analysis_result:
-                    return f"Erreur: {analysis_result['error']}", current_count, f"Nombre de mots : {current_count}"
-                
-                biases = analysis_result.get("biases", [])
-                advice = analysis_result.get("advice", [])
-                
-                if not biases and not advice:
-                    return "Aucun biais détecté ou conseils disponibles.", current_count, f"Nombre de mots : {current_count}"
-                
-                content = "<div style='display: flex; flex-wrap: wrap;'>"
-                for bias, adv in zip(biases, advice):
-                    content += f"""
-                    <div style='flex: 1; min-width: 300px; padding: 10px; text-align: center; border: 1px solid lightgray; border-radius: 20px; margin: 5px;'>
-                        <strong>{bias.upper()}</strong><br><br>{adv}
-                    </div>
-                    """
-                content += "</div>"
-                return content, current_count, f"Nombre de mots : {current_count}"
-            return gr.update(), previous_count, f"Nombre de mots : {current_count}"  # Conserver l'état précédent sans changement
-
-        # Utilisation du bouton pour déclencher l'analyse des biais
-        def analyze_button_click(objective_text, previous_count, realtime):
-            current_count = len(objective_text.split())
-            analysis_result = analyze_biases(objective_text)
-            if "error" in analysis_result:
-                return f"Erreur: {analysis_result['error']}", current_count, f"Nombre de mots : {current_count}"
-            
-            biases = analysis_result.get("biases", [])
-            advice = analysis_result.get("advice", [])
-            
-            if not biases and not advice:
-                return "Aucun biais détecté ou conseils disponibles.", current_count, f"Nombre de mots : {current_count}"
-            
-            content = "<div style='display: flex; flex-wrap: wrap;'>"
-            for bias, adv in zip(biases, advice):
-                content += f"""
-                <div style='flex: 1; min-width: 300px; padding: 10px; text-align: center; border: 1px solid lightgray; border-radius: 20px; margin: 5px;'>
-                    <strong>{bias.upper()}</strong><br><br>{adv}
-                </div>
-                """
-            content += "</div>"
-            return content, current_count, f"Nombre de mots : {current_count}"
-
-        # Utilisation du bouton pour déclencher l'analyse des biais
-        analyze_button.click(
-            fn=analyze_button_click,
-            inputs=[objective_input, word_count_state, realtime_analysis],
-            outputs=[bias_analysis_output, word_count_state, word_count_display]
-        )
+    if not first_name or not last_name or not age or not gender:
+        gr.Info("Veuillez remplir tous les champs pour générer l'image du persona.")
+        return None, update_log("Génération Image: Champs manquants.", session_log_state)
+
+    prompt = f"one person only. {first_name} {last_name}, {gender}, {age} years old. Realistic photo style."
+
+    # Mapping et ajout des détails
+    details = ""
+    if skin_color: details += f" Skin tone: {skin_color_mapping.get(skin_color, skin_color)}."
+    if eye_color: details += f" Eye color: {eye_color_mapping.get(eye_color, eye_color)}."
+    if hair_style: details += f" Hairstyle: {hair_style_mapping.get(hair_style, hair_style)}."
+    if hair_color: details += f" Hair color: {hair_color_mapping.get(hair_color, hair_color)}."
+    if facial_expression: details += f" Facial expression: {facial_expression_mapping.get(facial_expression, facial_expression)}."
+    if posture: details += f" Posture: {posture_mapping.get(posture, posture)}."
+    if clothing_style: details += f" Clothing style: {clothing_style_mapping.get(clothing_style, clothing_style)}."
+    if accessories: details += f" Accessories: {accessories_mapping.get(accessories, accessories)}."
+    if persona_description: details += f" Background context or activity: {persona_description}."
+
+    final_prompt = prompt + details
+    log_event_start = f"Génération Image (début): Prompt='{final_prompt[:100]}...'"
+    update_log(log_event_start, session_log_state)
 
-        # Utilisation de l'analyse en temps réel
-        objective_input.change(
-            fn=display_biases_and_advice,
-            inputs=[objective_input, word_count_state, realtime_analysis],
-            outputs=[bias_analysis_output, word_count_state, word_count_display]
+    try:
+        response = client.images.generate(
+            model="dall-e-3", # OpenRouter pourrait ne pas supporter DALL-E 3 directement, vérifier la compatibilité ou utiliser un modèle image dispo via OpenRouter
+                               # Alternative possible via OpenRouter : "stabilityai/stable-diffusion-xl-1024-v1-0" (nécessite ajustement)
+                               # Pour l'instant on laisse DALL-E 3 en supposant une clé OpenAI valide aussi, ou l'utilisateur devra adapter
+            prompt=final_prompt,
+            size="1024x1024",
+            n=1,
         )
+        image_url = response.data[0].url
+        response_image = requests.get(image_url)
+        response_image.raise_for_status() # Vérifie les erreurs HTTP
+
+        # Utiliser BytesIO pour éviter fichier temporaire si possible avec Gradio Image
+        # img_bytes = response_image.content
+        # pil_image = Image.open(BytesIO(img_bytes))
+        # return pil_image, update_log("Génération Image (fin): Succès.", session_log_state)
+
+        # Méthode avec fichier temporaire (comme V1) si BytesIO pose problème
+        temp_image = tempfile.NamedTemporaryFile(delete=False, suffix='.png')
+        with open(temp_image.name, 'wb') as f:
+            f.write(response_image.content)
+        image_path = temp_image.name
+        update_log(f"Génération Image (fin): Succès. Image @ {image_path}", session_log_state)
+        return image_path, update_log("", session_log_state) # Retourne chemin et log
 
-        # Afficher le compteur de mots
-        objective_input.change(
-            fn=lambda text: f"Nombre de mots : {len(text.split())}",
-            inputs=objective_input,
-            outputs=word_count_display
-        )
+    except Exception as e:
+        error_msg = f"Erreur lors de la génération de l'image: {str(e)}"
+        print(error_msg)
+        update_log(f"ERREUR Génération Image: {str(e)}", session_log_state)
+        gr.Error(error_msg)
+        return None, update_log("", session_log_state)
+
+def refine_persona_details_v2(first_name, last_name, age, field_name, field_value, bias_analysis_json_str, marketing_objectives, session_log_state):
+    """Affine les détails du persona (V2 avec lien aux biais et logging)."""
+
+    log_event_start = f"Refinement (début): Champ='{field_name}', Valeur initiale='{field_value[:50]}...'"
+    update_log(log_event_start, session_log_state)
+
+    # Essayer de récupérer les biais détectés précédemment
+    biases_text = "Aucune analyse de biais précédente disponible."
+    if bias_analysis_json_str:
+         try:
+             bias_analysis_data = json.loads(bias_analysis_json_str) # Charger depuis l'état caché
+             detected_biases = bias_analysis_data.get("detected_biases", [])
+             if detected_biases:
+                 biases_text = "\n".join([f"- {b['bias_type']}: {b['explanation']}" for b in detected_biases])
+             else:
+                 biases_text = "Aucun biais majeur détecté lors de l'analyse initiale."
+         except Exception as e:
+             biases_text = f"Erreur lors de la récupération des biais analysés: {e}"
 
-    with gr.Tab("Étape 2: Image du persona et informations de base"):
-        with gr.Row():
-            with gr.Column(scale=1.45):
-                first_name_input = gr.Textbox(label="Prénom")
-                last_name_input = gr.Textbox(label="Nom de famille")
-                age_input = gr.Slider(label="Âge", minimum=18, maximum=100, step=1)
-                gender_input = gr.Radio(label="Genre", choices=["homme", "femme"], value="homme")
-                persona_description_input = gr.Textbox(label="Description du persona (en anglais)", lines=1)
-                generate_image_button = gr.Button("Générer l'image du persona", elem_id="generate_image_button")
-            with gr.Column(scale=1):
-                persona_image_output = gr.Image(label="Image du persona", type="filepath")
-        
-        # Ajouter une infobulle sur les biais algorithmiques
-        gr.HTML("""
-        <style>
-            #generate_image_button {
-                position: relative;
-            }
-            #generate_image_button::after {
-                content: "Attention : Les algorithmes peuvent introduire des biais dans les images générées.";
-                position: absolute;
-                background: #f9f9f9;
-                border: 1px solid #ccc;
-                padding: 5px;
-                border-radius: 5px;
-                top: 100%;
-                left: 50%;
-                transform: translateX(-50%);
-                white-space: normal;
-                opacity: 0;
-                visibility: hidden;
-                transition: opacity 0.5s ease-in-out, visibility 0.5s;
-                width: max-content;
-                max-width: 300px;
-            }
-            #generate_image_button:hover::after {
-                visibility: visible;
-                opacity: 0;
-                transition-delay: 1.5s;
-            }
-            #generate_image_button:hover::after {
-                opacity: 1;
-            }
-        </style>
-        """)
-        
-        # Ajouter une liste accordéon pour les détails du prompt DALL-E 3
-        with gr.Accordion("Détails du prompt DALL-E 3"):
-            # Section 1: Caractéristiques physiques
-            with gr.Accordion("1. Caractéristiques physiques", open=False):
-                skin_color_input = gr.Dropdown(label="Teint de la peau", choices=list(skin_color_mapping.keys()), value="")
-                eye_color_input = gr.Dropdown(label="Couleur des yeux", choices=list(eye_color_mapping.keys()), value="")
-                hair_style_input = gr.Dropdown(label="Coiffure", choices=list(hair_style_mapping.keys()), value="")
-                hair_color_input = gr.Dropdown(label="Couleur des cheveux", choices=list(hair_color_mapping.keys()), value="")
-            
-            # Section 2: Expressions faciales et posture
-            with gr.Accordion("2. Expressions faciales et posture", open=False):
-                facial_expression_input = gr.Dropdown(label="Expression faciale", choices=list(facial_expression_mapping.keys()), value="")
-                posture_input = gr.Dropdown(label="Posture", choices=list(posture_mapping.keys()), value="")
-            
-            # Section 3: Style vestimentaire
-            with gr.Accordion("3. Style vestimentaire", open=False):
-                clothing_style_input = gr.Dropdown(label="Style de vêtements", choices=list(clothing_style_mapping.keys()), value="")
-                accessories_input = gr.Dropdown(label="Accessoires", choices=list(accessories_mapping.keys()), value="")
-            
-        generate_image_button.click(
-            fn=generate_persona_image,
-            inputs=[
-                first_name_input, last_name_input, age_input, gender_input, persona_description_input,
-                skin_color_input, eye_color_input, hair_style_input, hair_color_input,
-                facial_expression_input, posture_input,
-                clothing_style_input, accessories_input
-            ],
-            outputs=persona_image_output
+    system_prompt = f"""
+    Tu es un assistant IA expert en marketing éthique, aidant à affiner le persona marketing pour '{first_name} {last_name}' ({age} ans).
+    L'objectif marketing initial était : "{marketing_objectives}"
+    L'analyse initiale de cet objectif a soulevé les biais potentiels suivants :
+    {biases_text}
+
+    Tâche: Concentre-toi UNIQUEMENT sur le champ '{field_name}' dont la valeur actuelle est '{field_value}'.
+    Propose 1 à 2 suggestions CONCISES pour améliorer ou nuancer cette valeur.
+    Tes suggestions doivent viser à rendre le persona plus réaliste, moins stéréotypé, et/ou à ATTÉNUER les biais potentiels listés ci-dessus, tout en restant cohérent avec l'objectif marketing général.
+    Si la valeur actuelle semble bonne ou si tu manques de contexte, indique-le simplement.
+    Réponds en français. Ne fournis que les suggestions.
+    """
+    try:
+        response = client.chat.completions.create(
+            model=MODEL_NAME,
+            messages=[{"role": "user", "content": system_prompt}],
+            temperature=0.5, # Un peu plus de créativité pour les suggestions
+            max_tokens=150,
         )
+        suggestions = response.choices[0].message.content.strip()
 
-        # Ajouter un bouton de réinitialisation en bas du formulaire
-        reset_button = gr.Button("Réinitialiser")
+        log_event_end = f"Refinement (fin): Champ='{field_name}'. Suggestions: '{suggestions[:50]}...'"
+        update_log(log_event_end, session_log_state)
 
-        # Fonction pour réinitialiser les champs du formulaire
-        def reset_form():
-            return [""] * 8  # RLe nombre de champs à réinitialiser
+        # Affiche les suggestions dans une InfoBox
+        gr.Info(f"Suggestions pour '{field_name}':\n{suggestions}")
+        return update_log("", session_log_state) # Retourne juste le log mis à jour pour l'output invisible
 
-        # Associer le bouton de réinitialisation à la fonction reset_form
-        reset_button.click(
-            fn=reset_form,
-            inputs=[],
-            outputs=[
+    except Exception as e:
+        error_msg = f"Erreur lors du raffinement pour '{field_name}': {str(e)}"
+        print(error_msg)
+        update_log(f"ERREUR Refinement '{field_name}': {str(e)}", session_log_state)
+        gr.Error(error_msg)
+        return update_log("", session_log_state)
+
+def generate_summary_v2(*args):
+    """Génère le résumé du persona (V2 avec logging et meilleure gestion image)."""
+    # Les 28 premiers args sont les inputs persona, le 29ème est persona_image_path, le 30ème est session_log_state
+    inputs = args[:-1]
+    session_log_state = args[-1]
+    (first_name, last_name, age, gender, persona_description,
+     skin_color, eye_color, hair_style, hair_color, facial_expression,
+     posture, clothing_style, accessories,
+     marital_status, education_level, profession, income,
+     personality_traits, values_beliefs, motivations, hobbies_interests,
+     main_responsibilities, daily_activities, technology_relationship,
+     product_related_activities, pain_points, product_goals, usage_scenarios, # Ajout usage_scenarios
+     brand_relationship, market_segment, commercial_objectives, # Ajout autres champs V1
+     visual_codes, special_considerations, daily_life, references, # Ajout autres champs V1
+     persona_image_path # Récupère le chemin de l'image
+     ) = inputs
+
+    log_event = f"Génération Résumé: Pour '{first_name} {last_name}'."
+    update_log(log_event, session_log_state)
+
+    summary = ""
+    image_html = "<div style='flex: 0 0 320px; margin-left: 20px; text-align: center;'>\n" # Div pour l'image
+
+    if not first_name or not last_name or not age:
+        summary += "**Veuillez fournir au moins le prénom, le nom et l'âge (Étape 2).**\n"
+        image_html += "<p>Image non générée.</p>\n"
+    else:
+        # Essayer de charger et encoder l'image depuis le chemin stocké
+        if persona_image_path and os.path.exists(persona_image_path):
+            try:
+                with open(persona_image_path, "rb") as img_file:
+                    img_bytes = img_file.read()
+                    img_base64 = base64.b64encode(img_bytes).decode()
+                    img_data_url = f"data:image/png;base64,{img_base64}"
+                    image_html += f"<img src='{img_data_url}' alt='Persona {first_name}' style='max-width: 300px; height: auto; border: 1px solid #eee; border-radius: 5px;'/>\n"
+            except Exception as e:
+                image_html += f"<p>Erreur chargement image: {e}</p>\n"
+                update_log(f"ERREUR Chargement Image Résumé: {e}", session_log_state)
+        else:
+            image_html += "<p>Aucune image générée.</p>\n"
+
+        # Section Informations Personnelles (Titre centré)
+        summary += f"<div style='text-align: center;'><h1>{first_name} {last_name}, {age} ans ({gender})</h1></div>\n"
+        if persona_description: summary += f"<p><i>{persona_description}</i></p>\n"
+
+        # Assemblage des autres sections (avec vérification si champ rempli)
+        def add_section(title, fields):
+            content = ""
+            for label, value in fields.items():
+                if value: # N'ajoute que si la valeur existe
+                     # Formatage spécial pour les revenus
+                     if label == "Revenus annuels (€)" and isinstance(value, (int, float)):
+                         value_str = f"{value:,.0f} €".replace(",", " ") # Format numérique
+                     else:
+                         value_str = str(value)
+                     content += f"**{label}**: {value_str}<br>\n"
+            if content:
+                return f"<h3>{title}</h3>\n{content}<br>\n"
+            return ""
+
+        summary += add_section("Infos Socio-Démographiques", {
+            "État civil": marital_status, "Niveau d'éducation": education_level,
+            "Profession": profession, "Revenus annuels (€)": income
+        })
+        summary += add_section("Psychographie", {
+            "Traits de personnalité": personality_traits, "Valeurs et croyances": values_beliefs,
+            "Motivations intrinsèques": motivations, "Hobbies et intérêts": hobbies_interests
+        })
+        summary += add_section("Relation au Produit/Service", {
+            "Relation avec la technologie": technology_relationship,
+            "Tâches liées au produit": product_related_activities,
+            "Points de douleur (Pain points)": pain_points,
+            "Objectifs d’utilisation du produit": product_goals,
+            "Scénarios d’utilisation": usage_scenarios
+        })
+        summary += add_section("Contexte Professionnel/Vie Quotidienne", {
+             "Responsabilités principales": main_responsibilities,
+             "Activités journalières": daily_activities,
+             "Une journée dans la vie": daily_life
+        })
+        summary += add_section("Marketing & Considérations Spéciales", {
+             "Relation avec la marque": brand_relationship,
+             "Segment de marché": market_segment,
+             "Objectifs commerciaux (SMART)": commercial_objectives,
+             "Graphiques et codes visuels": visual_codes,
+             "Considérations spéciales (accessibilité)": special_considerations,
+             "Références (sources de données)": references
+        })
+
+    image_html += "</div>\n" # Ferme div image
+
+    # Assemblage final avec flexbox
+    final_html = "<div style='display: flex; flex-wrap: wrap; align-items: flex-start;'>\n"
+    final_html += f"<div style='flex: 1; min-width: 300px;'>\n{summary}</div>\n" # Colonne texte
+    final_html += image_html # Colonne image
+    final_html += "</div>"
+
+    return final_html, update_log("", session_log_state) # Retourne HTML et log
+
+# --- Interface Gradio V2 ---
+
+with gr.Blocks(theme=gr.themes.Soft(primary_hue="teal", secondary_hue="orange")) as demo:
+    gr.Markdown("# PersonaGenAI V2 : Assistant de Création de Persona")
+    gr.Markdown("Outil d'aide à la création de personas marketing, intégrant l'IA générative pour stimuler la créativité et la réflexivité face aux biais cognitifs et algorithmiques.")
+
+    # --- État Global ---
+    # Pour stocker le résultat de l'analyse de biais pour l'utiliser dans l'étape 3
+    # Utiliser du JSON comme chaîne de caractères pour passer des données structurées
+    bias_analysis_result_state = gr.State(value=None)
+    # Pour stocker le chemin de l'image générée
+    persona_image_path_state = gr.State(value=None)
+    # Pour stocker le log de session
+    session_log_state = gr.State(value="")
+
+    with gr.Tabs() as tabs:
+
+        # --- Onglet 0 : Configuration API (Optionnel mais bonne pratique) ---
+        with gr.Tab("🔑 Configuration API", id=-1):
+            gr.Markdown("### Configuration OpenRouter API")
+            gr.Markdown(f"Utilise le modèle : `{MODEL_NAME}` via OpenRouter. Utiliser : google/gemini-2.5-pro-exp-03-25:free")
+            # Possibilité d'ajouter un input pour changer la clé si besoin, mais pas essentiel pour la démo AIMS
+            gr.HTML(f"<small>Clé utilisée (tronquée): {api_key[:10]}...{api_key[-4:] if len(api_key)>14 else ''}</small>")
+
+
+        # --- Onglet 1 : Objectif & Analyse Biais ---
+        with gr.Tab("🎯 Étape 1: Objectif & Analyse Biais", id=0):
+            gr.Markdown("### 1. Définissez votre objectif marketing")
+            gr.Markdown("Décrivez pourquoi vous créez ce persona. L'IA analysera votre objectif pour identifier des biais cognitifs potentiels.")
+            with gr.Row():
+                objective_input = gr.Textbox(label="Objectif marketing pour ce persona", lines=4, scale=3)
+                with gr.Column(scale=1):
+                    # Exemples pour guider l'utilisateur
+                    gr.Markdown("<small>Suggestions d'objectifs :</small>")
+                    suggestion_button1 = gr.Button("Exemple 1 : Service Écologique Urbain", size="sm")
+                    suggestion_button2 = gr.Button("Exemple 2 : App Fitness Seniors", size="sm")
+            analyze_button = gr.Button("🔍 Analyser l'Objectif pour Biais")
+            gr.Markdown("---")
+            gr.Markdown("### Analyse des Biais Potentiels")
+            bias_analysis_output_highlighted = gr.HighlightedText(
+                label="Biais détectés et Conseils",
+                show_legend=True,
+                color_map={"BIAS_TYPE": "red", "EXPLANATION": "gray", "ADVICE": "green", "INFO": "blue", "COMMENT": "orange"}
+            )
+            gr.Markdown("---")
+            gr.Markdown("### 🤔 Réflexion")
+            user_reflection_on_biases = gr.Textbox(
+                label="Comment comptez-vous utiliser cette analyse pour la suite ?",
+                lines=2,
+                placeholder="Ex: Je vais veiller à ne pas tomber dans le stéréotype X, je vais chercher des données pour nuancer Y..."
+            )
+            log_reflection_button = gr.Button("📝 Enregistrer la réflexion", size='sm')
+
+            # Logique de l'onglet 1
+            suggestion1_text = "Je souhaite créer un persona pour promouvoir un nouveau service de livraison écologique destiné aux jeunes professionnels urbains soucieux de l'environnement (25-35 ans). Il doit incarner ces valeurs et besoins identifiés lors de notre étude préalable."
+            suggestion2_text = "Développer une application mobile de fitness personnalisée pour les seniors actifs (+65 ans) cherchant à maintenir une vie saine et sociale. Le persona doit refléter leurs besoins (facilité, convivialité) et préférences."
+
+            suggestion_button1.click(lambda: suggestion1_text, outputs=objective_input)
+            suggestion_button2.click(lambda: suggestion2_text, outputs=objective_input)
+
+            analyze_button.click(
+                fn=analyze_biases_v2,
+                inputs=[objective_input, session_log_state],
+                outputs=[bias_analysis_result_state, session_log_state] # Stocke le résultat JSON brut dans l'état
+            ).then(
+                 fn=display_bias_analysis_v2,
+                 inputs=bias_analysis_result_state, # Utilise le résultat stocké
+                 outputs=[bias_analysis_output_highlighted, bias_analysis_result_state] # Affiche formaté + remet dans l'état (pour màj)
+            ).then(
+                 fn=lambda log: update_log("", log), # Force la MAJ du log display via l'état
+                 inputs=session_log_state,
+                 outputs=session_log_state # Ne change rien mais déclenche l'update du textbox log
+            )
+
+            def log_user_reflection(reflection_text, log_state):
+                update_log(f"Réflexion Utilisateur (Étape 1): '{reflection_text}'", log_state)
+                return update_log("", log_state)
+
+            log_reflection_button.click(
+                fn=log_user_reflection,
+                inputs=[user_reflection_on_biases, session_log_state],
+                outputs=[session_log_state]
+            )
+
+        # --- Onglet 2 : Image & Infos Base ---
+        with gr.Tab("👤 Étape 2: Image & Infos Base", id=1):
+            gr.Markdown("### 2. Créez l'identité visuelle et les informations de base")
+            with gr.Row():
+                with gr.Column(scale=1.4): # Colonne de gauche pour les inputs
+                    first_name_input = gr.Textbox(label="Prénom")
+                    last_name_input = gr.Textbox(label="Nom")
+                    age_input = gr.Slider(label="Âge", minimum=18, maximum=100, step=1, value=30)
+                    gender_input = gr.Radio(label="Genre", choices=["Homme", "Femme", "Non-binaire"], value="Homme") # Ajout Non-binaire
+                    persona_description_input = gr.Textbox(label="Contexte/Activité pour l'image (optionnel, en anglais)", lines=1)
+
+                    with gr.Accordion("🎨 Détails Visuels (Optionnel)", open=False):
+                         with gr.Row():
+                              skin_color_input = gr.Dropdown(label="Teint", choices=list(skin_color_mapping.keys()), value="")
+                              eye_color_input = gr.Dropdown(label="Yeux", choices=list(eye_color_mapping.keys()), value="")
+                         with gr.Row():
+                              hair_style_input = gr.Dropdown(label="Coiffure", choices=list(hair_style_mapping.keys()), value="")
+                              hair_color_input = gr.Dropdown(label="Cheveux", choices=list(hair_color_mapping.keys()), value="")
+                         with gr.Row():
+                              facial_expression_input = gr.Dropdown(label="Expression", choices=list(facial_expression_mapping.keys()), value="")
+                              posture_input = gr.Dropdown(label="Posture", choices=list(posture_mapping.keys()), value="")
+                         with gr.Row():
+                              clothing_style_input = gr.Dropdown(label="Style Vêtements", choices=list(clothing_style_mapping.keys()), value="")
+                              accessories_input = gr.Dropdown(label="Accessoires", choices=list(accessories_mapping.keys()), value="")
+                    reset_visuals_button = gr.Button("Réinitialiser Détails Visuels", size="sm")
+
+                with gr.Column(scale=1): # Colonne de droite pour l'image et le bouton
+                     persona_image_output = gr.Image(label="Image du Persona", type="filepath", height=400) # filepath pour stocker le chemin
+                     generate_image_button = gr.Button("🖼️ Générer / Mettre à jour l'Image")
+                     gr.Markdown("<small>💡 **Attention :** Les IA génératrices d'images peuvent reproduire des stéréotypes. Utilisez les détails visuels pour créer une représentation nuancée et inclusive.</small>", elem_classes="warning")
+
+            # Logique de l'onglet 2
+            visual_inputs = [
                 skin_color_input, eye_color_input, hair_style_input, hair_color_input,
                 facial_expression_input, posture_input, clothing_style_input, accessories_input
             ]
-        )
-
-    with gr.Tab("Étape 3: Profil détaillé du persona"):
-
-        # Section 1: Informations de base
-        with gr.Accordion("1. Informations de base", open=True):
-            with gr.Row():
-                marital_status_input = gr.Dropdown(label="État civil", choices=["Célibataire", "En couple", "Marié(e)", "Divorcé(e)", "Veuf(ve)"])
-            with gr.Row():
-                education_level_input = gr.Dropdown(label="Niveau d'éducation", choices=["Études secondaires", "Bachelier", "Master", "Doctorat", "Autre"])
-            with gr.Row():
-                profession_input = gr.Textbox(label="Profession")
-            with gr.Row():
-                income_input = gr.Number(label="Revenus annuels (€)")
-            with gr.Row():
-                personality_traits_input = gr.Textbox(
-                    label="Traits de personnalité (introverti/extraverti, etc.)",
-                    lines=1,
-                    info="Ensemble des caractéristiques qui définissent l'individualité d'une personne, incluant ses comportements stables et uniques."
-                )
-                refine_personality_traits_button = gr.Button("Affiner", scale=0.05)
-            with gr.Row():
-                values_beliefs_input = gr.Textbox(label="Valeurs et croyances", lines=1)
-                refine_values_beliefs_button = gr.Button("Affiner", scale=0.05)
-            with gr.Row():
-                motivations_input = gr.Textbox(
-                    label="Motivations intrinsèques",
-                    lines=1,
-                    info="[Motivations internes qui poussent une personne à agir par plaisir ou satisfaction personnelle](https://fr.wikipedia.org/wiki/Motivation), sans attendre de récompenses externes."
-                )
-                refine_motivations_button = gr.Button("Affiner", scale=0.05)
-            with gr.Row():
-                hobbies_interests_input = gr.Textbox(label="Hobbies et intérêts", lines=1)
-                refine_hobbies_interests_button = gr.Button("Affiner", scale=0.05)
-
-        # Section 2: Informations liées au design
-        with gr.Accordion("2. Informations liées au design", open=False):
-            with gr.Row():
-                main_responsibilities_input = gr.Textbox(label="Responsabilités principales", lines=1)
-                refine_main_responsibilities_button = gr.Button("Affiner", scale=0.05)
-            with gr.Row():
-                daily_activities_input = gr.Textbox(label="Activités journalières", lines=1)
-                refine_daily_activities_button = gr.Button("Affiner", scale=0.05)
-            with gr.Row():
-                technology_relationship_input = gr.Textbox(label="Relation avec la technologie", lines=1)
-                refine_technology_relationship_button = gr.Button("Affiner", scale=0.05)
-            with gr.Row():
-                product_related_activities_input = gr.Textbox(label="Tâches liées au produit", lines=1)
-                refine_product_related_activities_button = gr.Button("Affiner", scale=0.05)
-            with gr.Row():
-                pain_points_input = gr.Textbox(
-                    label="Points de douleur (pain points)",
-                    lines=1,
-                    info="Problèmes ou frustrations auxquels un client peut être confronté lors de son parcours d'achat, tels qu'un mauvais service ou des délais d'attente excessifs."
-                )
-                refine_pain_points_button = gr.Button("Affiner", scale=0.05)
-            with gr.Row():
-                product_goals_input = gr.Textbox(label="Objectifs d’utilisation du produit", lines=1)
-                refine_product_goals_button = gr.Button("Affiner", scale=0.05)
-            with gr.Row():
-                usage_scenarios_input = gr.Textbox(label="Scénarios d’utilisation", lines=1)
-                refine_usage_scenarios_button = gr.Button("Affiner", scale=0.05)
-
-        # Section 3: Informations marketing et commerciales
-        with gr.Accordion("3. Informations marketing et commerciales", open=False):
-            with gr.Row():
-                brand_relationship_input = gr.Textbox(label="Relation avec la marque", lines=1)
-                refine_brand_relationship_button = gr.Button("Affiner", scale=0.05)
-            with gr.Row():
-                market_segment_input = gr.Textbox(label="Segment de marché", lines=1)
-                refine_market_segment_button = gr.Button("Affiner", scale=0.05)
-            with gr.Row():
-                commercial_objectives_input = gr.Textbox(
-                    label="Objectifs commerciaux",
-                    lines=1,
-                    info="Objectifs clairs et mesurables que l'on souhaite atteindre, souvent décrits selon la méthode [SMART](https://fr.wikipedia.org/wiki/Objectifs_et_indicateurs_SMART) pour assurer leur réalisabilité."
-                )
-                refine_commercial_objectives_button = gr.Button("Affiner", scale=0.05)
-
-        # Section 4: Graphismes et accessibilité
-        with gr.Accordion("4. Graphismes et accessibilité", open=False):
-            with gr.Row():
-                visual_codes_input = gr.Textbox(label="Graphiques et codes visuels", lines=1)
-                refine_visual_codes_button = gr.Button("Affiner", scale=0.05)
-            with gr.Row():
-                special_considerations_input = gr.Textbox(label="Considérations spéciales (accessibilité)", lines=1)
-                refine_special_considerations_button = gr.Button("Affiner", scale=0.05)
-
-        # Section 5: Dimensions supplémentaires
-        with gr.Accordion("5. Dimensions supplémentaires", open=False):
-            with gr.Row():
-                daily_life_input = gr.Textbox(label="Une journée dans la vie", lines=1)
-                refine_daily_life_button = gr.Button("Affiner", scale=0.05)
-            with gr.Row():
-                references_input = gr.Textbox(label="Références (sources de données)", lines=1)
-                refine_references_button = gr.Button("Affiner", scale=0.05)
-
-        # Zone de sortie pour les suggestions affinées
-        refined_suggestions_output = gr.Markdown(label="Suggestions affinées")
-
-        refine_personality_traits_button.click(
-            fn=lambda first_name, last_name, age, value, biases, marketing_objectives: refine_persona_details(first_name, last_name, age, "Traits de personnalité", value, biases, marketing_objectives),
-            inputs=[first_name_input, last_name_input, age_input, personality_traits_input, bias_analysis_output, objective_input],
-            outputs=[]
-        )
-        refine_values_beliefs_button.click(
-            fn=lambda first_name, last_name, age, value, biases, marketing_objectives: refine_persona_details(first_name, last_name, age, "Valeurs et croyances", value, biases, marketing_objectives),
-            inputs=[first_name_input, last_name_input, age_input, values_beliefs_input, bias_analysis_output, objective_input],
-            outputs=[]
-        )
-        refine_motivations_button.click(
-            fn=lambda first_name, last_name, age, value, biases, marketing_objectives: refine_persona_details(first_name, last_name, age, "Motivations intrinsèques", value, biases, marketing_objectives),
-            inputs=[first_name_input, last_name_input, age_input, motivations_input, bias_analysis_output, objective_input],
-            outputs=[]
-        )
-        refine_hobbies_interests_button.click(
-            fn=lambda first_name, last_name, age, value, biases, marketing_objectives: refine_persona_details(first_name, last_name, age, "Hobbies et intérêts", value, biases, marketing_objectives),
-            inputs=[first_name_input, last_name_input, age_input, hobbies_interests_input, bias_analysis_output, objective_input],
-            outputs=[]
-        )
-        refine_main_responsibilities_button.click(
-            fn=lambda first_name, last_name, age, value, biases, marketing_objectives: refine_persona_details(first_name, last_name, age, "Responsabilités principales", value, biases, marketing_objectives),
-            inputs=[first_name_input, last_name_input, age_input, main_responsibilities_input, bias_analysis_output, objective_input],
-            outputs=[]
-        )
-        refine_daily_activities_button.click(
-            fn=lambda first_name, last_name, age, value, biases, marketing_objectives: refine_persona_details(first_name, last_name, age, "Activités journalières", value, biases, marketing_objectives),
-            inputs=[first_name_input, last_name_input, age_input, daily_activities_input, bias_analysis_output, objective_input],
-            outputs=[]
-        )
-        refine_technology_relationship_button.click(
-            fn=lambda first_name, last_name, age, value, biases, marketing_objectives: refine_persona_details(first_name, last_name, age, "Relation avec la technologie", value, biases, marketing_objectives),
-            inputs=[first_name_input, last_name_input, age_input, technology_relationship_input, bias_analysis_output, objective_input],
-            outputs=[]
-        )
-        refine_product_related_activities_button.click(
-            fn=lambda first_name, last_name, age, value, biases, marketing_objectives: refine_persona_details(first_name, last_name, age, "Tâches liées au produit", value, biases, marketing_objectives),
-            inputs=[first_name_input, last_name_input, age_input, product_related_activities_input, bias_analysis_output, objective_input],
-            outputs=[]
-        )
-        refine_pain_points_button.click(
-            fn=lambda first_name, last_name, age, value, biases, marketing_objectives: refine_persona_details(first_name, last_name, age, "Points de douleur", value, biases, marketing_objectives),
-            inputs=[first_name_input, last_name_input, age_input, pain_points_input, bias_analysis_output, objective_input],
-            outputs=[]
-        )
-        refine_product_goals_button.click(
-            fn=lambda first_name, last_name, age, value, biases, marketing_objectives: refine_persona_details(first_name, last_name, age, "Objectifs d’utilisation du produit", value, biases, marketing_objectives),
-            inputs=[first_name_input, last_name_input, age_input, product_goals_input, bias_analysis_output, objective_input],
-            outputs=[]
-        )
-        refine_usage_scenarios_button.click(
-            fn=lambda first_name, last_name, age, value, biases, marketing_objectives: refine_persona_details(first_name, last_name, age, "Scénarios d’utilisation", value, biases, marketing_objectives),
-            inputs=[first_name_input, last_name_input, age_input, usage_scenarios_input, bias_analysis_output, objective_input],
-            outputs=[]
-        )
-        refine_brand_relationship_button.click(
-            fn=lambda first_name, last_name, age, value, biases, marketing_objectives: refine_persona_details(first_name, last_name, age, "Relation avec la marque", value, biases, marketing_objectives),
-            inputs=[first_name_input, last_name_input, age_input, brand_relationship_input, bias_analysis_output, objective_input],
-            outputs=[]
-        )
-        refine_market_segment_button.click(
-            fn=lambda first_name, last_name, age, value, biases, marketing_objectives: refine_persona_details(first_name, last_name, age, "Segment de marché", value, biases, marketing_objectives),
-            inputs=[first_name_input, last_name_input, age_input, market_segment_input, bias_analysis_output, objective_input],
-            outputs=[]
-        )
-        refine_commercial_objectives_button.click(
-            fn=lambda first_name, last_name, age, value, biases, marketing_objectives: refine_persona_details(first_name, last_name, age, "Objectifs commerciaux", value, biases, marketing_objectives),
-            inputs=[first_name_input, last_name_input, age_input, commercial_objectives_input, bias_analysis_output, objective_input],
-            outputs=[]
-        )
-        refine_visual_codes_button.click(
-            fn=lambda first_name, last_name, age, value, biases, marketing_objectives: refine_persona_details(first_name, last_name, age, "Graphiques et codes visuels", value, biases, marketing_objectives),
-            inputs=[first_name_input, last_name_input, age_input, visual_codes_input, bias_analysis_output, objective_input],
-            outputs=[]
-        )
-        refine_special_considerations_button.click(
-            fn=lambda first_name, last_name, age, value, biases, marketing_objectives: refine_persona_details(first_name, last_name, age, "Considérations spéciales", value, biases, marketing_objectives),
-            inputs=[first_name_input, last_name_input, age_input, special_considerations_input, bias_analysis_output, objective_input],
-            outputs=[]
-        )
-        refine_daily_life_button.click(
-            fn=lambda first_name, last_name, age, value, biases, marketing_objectives: refine_persona_details(first_name, last_name, age, "Une journée dans la vie", value, biases, marketing_objectives),
-            inputs=[first_name_input, last_name_input, age_input, daily_life_input, bias_analysis_output, objective_input],
-            outputs=[]
-        )
-        refine_references_button.click(
-            fn=lambda first_name, last_name, age, value, biases, marketing_objectives: refine_persona_details(first_name, last_name, age, "Références", value, biases, marketing_objectives),
-            inputs=[first_name_input, last_name_input, age_input, references_input, bias_analysis_output, objective_input],
-            outputs=[]
-        )
-    with gr.Tab("Étape 4: Résumé du persona"):
-        gr.Markdown("")
-        summary_button = gr.Button("Afficher le résumé")
-        summary_content = gr.Markdown()
-        
-        def generate_summary(
-            first_name, last_name, age, gender, persona_description,
-            skin_color, eye_color, hair_style, hair_color, facial_expression,
-            posture, clothing_style, accessories,
-            marital_status, education_level, profession, income,
-            personality_traits, values_beliefs, motivations, hobbies_interests,
-            main_responsibilities, daily_activities, technology_relationship,
-            product_related_activities, pain_points, product_goals, persona_image_output
-        ):
-            summary = ""
-
-            if not first_name or not last_name or not age:
-                summary += "**Veuillez fournir les informations de base du persona (prénom, nom, âge).**\n\n"
-                return summary
-                
-            image = None
-            if persona_image_output and os.path.exists(persona_image_output):
-                try:
-                    with open(persona_image_output, "rb") as img_file:
-                        img_bytes = img_file.read()
-                        img_base64 = base64.b64encode(img_bytes).decode()
-                        img_data_url = f"data:image/png;base64,{img_base64}"
-                        image = img_data_url
-                except Exception as e:
-                    summary += f"**Erreur lors du chargement de l'image:** {str(e)}\n\n"
-            
-            # Section Informations Personnelles
-            personal_info = ""
-            if first_name or last_name or age or gender or persona_description:
-                personal_info += "<div style='text-align: center;'>\n"
-                if first_name or last_name or age:
-                    personal_info += f"<h1>{first_name} {last_name}, {age} ans</h1>\n"
-                if persona_description:
-                    personal_info += f"**Description**: {persona_description}\n\n"
-                personal_info += "</div>\n"
-            
-            # Section Informations Sociales
-            social_info = ""
-            if marital_status or education_level or profession or income:
-                if marital_status:
-                    social_info += f"**État civil**: {marital_status}\n\n"
-                if education_level:
-                    social_info += f"**Niveau d'éducation**: {education_level}\n\n"
-                if profession:
-                    social_info += f"**Profession**: {profession}\n\n"
-                if income:
-                    social_info += f"**Revenus annuels (€)**: {income}\n\n"
-            
-            # Section Traits de Personnalité
-            personality_info = ""
-            if personality_traits or values_beliefs or motivations or hobbies_interests:
-                if personality_traits:
-                    personality_info += f"**Traits de personnalité**: {personality_traits}\n\n"
-                if values_beliefs:
-                    personality_info += f"**Valeurs et croyances**: {values_beliefs}\n\n"
-                if motivations:
-                    personality_info += f"**Motivations intrinsèques**: {motivations}\n\n"
-                if hobbies_interests:
-                    personality_info += f"**Hobbies et intérêts**: {hobbies_interests}\n\n"
-            
-            # Section Responsabilités et Activités
-            responsibilities_info = ""
-            if main_responsibilities or daily_activities or technology_relationship or product_related_activities:
-                if main_responsibilities:
-                    responsibilities_info += f"**Responsabilités principales**: {main_responsibilities}\n\n"
-                if daily_activities:
-                    responsibilities_info += f"**Activités journalières**: {daily_activities}\n\n"
-                if technology_relationship:
-                    responsibilities_info += f"**Relation avec la technologie**: {technology_relationship}\n\n"
-                if product_related_activities:
-                    responsibilities_info += f"**Tâches liées au produit**: {product_related_activities}\n\n"
-            
-            # Section Points de Douleur et Objectifs
-            pain_goals_info = ""
-            if pain_points or product_goals:
-                if pain_points:
-                    pain_goals_info += f"**Points de douleur**: {pain_points}\n\n"
-                if product_goals:
-                    pain_goals_info += f"**Objectifs d’utilisation du produit**: {product_goals}\n\n"
-            
-            # Assembler le résumé complet avec image à droite
-            summary += "<div style='display: flex; flex-wrap: nowrap; align-items: flex-start;'>\n"
-            
-            # Colonne pour le texte
-            summary += "<div style='flex: 1; margin-right: 20px;'>\n"
-            if personal_info:
-                summary += f"{personal_info}\n"
-            if social_info:
-                summary += "<h3>Informations sociales</h3>\n\n" + social_info
-            if personality_info:
-                summary += "<h3>Traits de personnalité</h3>\n\n" + personality_info
-            if responsibilities_info:
-                summary += "<h3>Responsabilités et Activités</h3>\n\n" + responsibilities_info
-            if pain_goals_info:
-                summary += "<h3>Points de Douleur et Objectifs</h3>\n\n" + pain_goals_info
-            summary += "</div>\n"
-            
-            # Colonne pour l'image alignée à droite
-            if image:
-                summary += f"<div style='flex: 0;'>\n<img src='{image}' alt='Persona Image' style='max-width: 300px; height: auto;'/>\n</div>\n"
-            else:
-                summary += "<div style='flex: 0;'>\n<p>Image non disponible.</p>\n</div>\n"
-            
-            summary += "</div>\n"
-            
-            return summary
-        
-        summary_button.click(
-            fn=generate_summary,
-            inputs=[
+            reset_visuals_button.click(lambda: [""] * len(visual_inputs), outputs=visual_inputs)
+
+            generate_image_button.click(
+                fn=generate_persona_image_v2,
+                inputs=[
+                    first_name_input, last_name_input, age_input, gender_input, persona_description_input,
+                    skin_color_input, eye_color_input, hair_style_input, hair_color_input,
+                    facial_expression_input, posture_input, clothing_style_input, accessories_input,
+                    session_log_state # Passer l'état du log
+                ],
+                outputs=[persona_image_path_state, session_log_state] # Stocker le chemin de l'image dans l'état
+            ).then(
+                lambda path_state: path_state.value, # Récupérer la valeur du chemin depuis l'état
+                inputs=persona_image_path_state,
+                outputs=persona_image_output # Mettre à jour l'affichage de l'image
+            )
+
+
+        # --- Onglet 3 : Profil Détaillé & Raffinement IA ---
+        with gr.Tab("📝 Étape 3: Profil Détaillé & Raffinement IA", id=2):
+             gr.Markdown("### 3. Complétez les détails du persona")
+             gr.Markdown("Remplissez les champs suivants. Utilisez le bouton '💡 Affiner' pour obtenir des suggestions de l'IA visant à améliorer le champ spécifique, en tenant compte de votre objectif initial et des biais potentiels identifiés.")
+
+             # Organiser en sections pour plus de clarté
+             with gr.Row():
+                 with gr.Column():
+                     gr.Markdown("#### Infos Socio-Démographiques")
+                     marital_status_input = gr.Dropdown(label="État civil", choices=["", "Célibataire", "En couple", "Marié(e)", "Divorcé(e)", "Veuf(ve)"])
+                     education_level_input = gr.Dropdown(label="Niveau d'éducation", choices=["", "Études secondaires", "Baccalauréat", "Licence", "Master", "Doctorat", "Autre"])
+                     profession_input = gr.Textbox(label="Profession")
+                     income_input = gr.Number(label="Revenus annuels (€)", minimum=0, step=1000)
+
+                     gr.Markdown("#### Psychographie")
+                     with gr.Row(equal_height=False):
+                         personality_traits_input = gr.Textbox(label="Traits de personnalité", lines=2, scale=4)
+                         refine_personality_traits_button = gr.Button("💡 Affiner", scale=1, size='sm')
+                     with gr.Row(equal_height=False):
+                         values_beliefs_input = gr.Textbox(label="Valeurs et croyances", lines=2, scale=4)
+                         refine_values_beliefs_button = gr.Button("💡 Affiner", scale=1, size='sm')
+                     with gr.Row(equal_height=False):
+                         motivations_input = gr.Textbox(label="Motivations (objectifs, désirs)", lines=2, scale=4)
+                         refine_motivations_button = gr.Button("💡 Affiner", scale=1, size='sm')
+                     with gr.Row(equal_height=False):
+                         hobbies_interests_input = gr.Textbox(label="Loisirs et intérêts", lines=2, scale=4)
+                         refine_hobbies_interests_button = gr.Button("💡 Affiner", scale=1, size='sm')
+
+                 with gr.Column():
+                     gr.Markdown("#### Relation au Produit/Service")
+                     with gr.Row(equal_height=False):
+                         technology_relationship_input = gr.Textbox(label="Relation avec la technologie (ex: early adopter, prudent...)", lines=2, scale=4)
+                         refine_technology_relationship_button = gr.Button("💡 Affiner", scale=1, size='sm')
+                     with gr.Row(equal_height=False):
+                         product_related_activities_input = gr.Textbox(label="Tâches/activités liées à votre produit/service", lines=2, scale=4)
+                         refine_product_related_activities_button = gr.Button("💡 Affiner", scale=1, size='sm')
+                     with gr.Row(equal_height=False):
+                         pain_points_input = gr.Textbox(label="Points de douleur (frustrations, problèmes)", lines=2, scale=4)
+                         refine_pain_points_button = gr.Button("💡 Affiner", scale=1, size='sm')
+                     with gr.Row(equal_height=False):
+                         product_goals_input = gr.Textbox(label="Objectifs en utilisant votre produit/service", lines=2, scale=4)
+                         refine_product_goals_button = gr.Button("💡 Affiner", scale=1, size='sm')
+                     with gr.Row(equal_height=False):
+                         usage_scenarios_input = gr.Textbox(label="Scénarios d'utilisation typiques", lines=2, scale=4)
+                         refine_usage_scenarios_button = gr.Button("💡 Affiner", scale=1, size='sm')
+
+             # Ajouter les autres champs de V1 ici si nécessaire (Responsabilités, Journée type, Marketing...) pour un persona complet
+             with gr.Accordion("Autres Informations (Optionnel)", open=False):
+                 with gr.Row():
+                     with gr.Column():
+                          gr.Markdown("#### Contexte Professionnel/Vie Quotidienne")
+                          with gr.Row(equal_height=False):
+                             main_responsibilities_input = gr.Textbox(label="Responsabilités principales (pro/perso)", lines=2, scale=4)
+                             refine_main_responsibilities_button = gr.Button("💡 Affiner", scale=1, size='sm')
+                          with gr.Row(equal_height=False):
+                             daily_activities_input = gr.Textbox(label="Activités journalières typiques", lines=2, scale=4)
+                             refine_daily_activities_button = gr.Button("💡 Affiner", scale=1, size='sm')
+                          with gr.Row(equal_height=False):
+                             daily_life_input = gr.Textbox(label="Une journée type / Citation marquante", lines=2, scale=4)
+                             refine_daily_life_button = gr.Button("💡 Affiner", scale=1, size='sm')
+
+                     with gr.Column():
+                          gr.Markdown("#### Marketing & Considérations Spéciales")
+                          with gr.Row(equal_height=False):
+                             brand_relationship_input = gr.Textbox(label="Relation avec la marque", lines=2, scale=4)
+                             refine_brand_relationship_button = gr.Button("💡 Affiner", scale=1, size='sm')
+                          with gr.Row(equal_height=False):
+                             market_segment_input = gr.Textbox(label="Segment de marché", lines=2, scale=4)
+                             refine_market_segment_button = gr.Button("💡 Affiner", scale=1, size='sm')
+                          with gr.Row(equal_height=False):
+                             commercial_objectives_input = gr.Textbox(label="Objectifs commerciaux liés (SMART)", lines=2, scale=4)
+                             refine_commercial_objectives_button = gr.Button("💡 Affiner", scale=1, size='sm')
+                          with gr.Row(equal_height=False):
+                             visual_codes_input = gr.Textbox(label="Codes visuels / Marques préférées", lines=2, scale=4)
+                             refine_visual_codes_button = gr.Button("💡 Affiner", scale=1, size='sm')
+                          with gr.Row(equal_height=False):
+                             special_considerations_input = gr.Textbox(label="Considérations spéciales (accessibilité, culturelles...)", lines=2, scale=4)
+                             refine_special_considerations_button = gr.Button("💡 Affiner", scale=1, size='sm')
+                          with gr.Row(equal_height=False):
+                             references_input = gr.Textbox(label="Références / Sources de données", lines=2, scale=4)
+                             refine_references_button = gr.Button("💡 Affiner", scale=1, size='sm')
+
+             # Fonction lambda générique pour appeler refine_persona_details_v2
+             def create_refine_lambda(field_name_display, input_component):
+                 return lambda fname, lname, age_val, field_val, bias_state, objectives, log_state: \
+                     refine_persona_details_v2(fname, lname, age_val, field_name_display, field_val, json.dumps(bias_state) if bias_state else None, objectives, log_state)
+
+             # Lier chaque bouton "Affiner"
+             common_inputs = [first_name_input, last_name_input, age_input]
+             state_inputs = [bias_analysis_result_state, objective_input, session_log_state]
+             common_outputs = [session_log_state] # Sortie invisible pour mettre à jour le log
+
+             refine_personality_traits_button.click(create_refine_lambda("Traits de personnalité", personality_traits_input), inputs=common_inputs + [personality_traits_input] + state_inputs, outputs=common_outputs)
+             refine_values_beliefs_button.click(create_refine_lambda("Valeurs et croyances", values_beliefs_input), inputs=common_inputs + [values_beliefs_input] + state_inputs, outputs=common_outputs)
+             refine_motivations_button.click(create_refine_lambda("Motivations", motivations_input), inputs=common_inputs + [motivations_input] + state_inputs, outputs=common_outputs)
+             refine_hobbies_interests_button.click(create_refine_lambda("Loisirs et intérêts", hobbies_interests_input), inputs=common_inputs + [hobbies_interests_input] + state_inputs, outputs=common_outputs)
+             refine_technology_relationship_button.click(create_refine_lambda("Relation avec la technologie", technology_relationship_input), inputs=common_inputs + [technology_relationship_input] + state_inputs, outputs=common_outputs)
+             refine_product_related_activities_button.click(create_refine_lambda("Tâches liées au produit", product_related_activities_input), inputs=common_inputs + [product_related_activities_input] + state_inputs, outputs=common_outputs)
+             refine_pain_points_button.click(create_refine_lambda("Points de douleur", pain_points_input), inputs=common_inputs + [pain_points_input] + state_inputs, outputs=common_outputs)
+             refine_product_goals_button.click(create_refine_lambda("Objectifs produit", product_goals_input), inputs=common_inputs + [product_goals_input] + state_inputs, outputs=common_outputs)
+             refine_usage_scenarios_button.click(create_refine_lambda("Scénarios d'utilisation", usage_scenarios_input), inputs=common_inputs + [usage_scenarios_input] + state_inputs, outputs=common_outputs)
+             # Ajouter les clics pour les autres boutons "Affiner" si ajoutés...
+             refine_main_responsibilities_button.click(create_refine_lambda("Responsabilités principales", main_responsibilities_input), inputs=common_inputs + [main_responsibilities_input] + state_inputs, outputs=common_outputs)
+             refine_daily_activities_button.click(create_refine_lambda("Activités journalières", daily_activities_input), inputs=common_inputs + [daily_activities_input] + state_inputs, outputs=common_outputs)
+             refine_daily_life_button.click(create_refine_lambda("Journée type/Citation", daily_life_input), inputs=common_inputs + [daily_life_input] + state_inputs, outputs=common_outputs)
+             refine_brand_relationship_button.click(create_refine_lambda("Relation marque", brand_relationship_input), inputs=common_inputs + [brand_relationship_input] + state_inputs, outputs=common_outputs)
+             refine_market_segment_button.click(create_refine_lambda("Segment marché", market_segment_input), inputs=common_inputs + [market_segment_input] + state_inputs, outputs=common_outputs)
+             refine_commercial_objectives_button.click(create_refine_lambda("Objectifs commerciaux", commercial_objectives_input), inputs=common_inputs + [commercial_objectives_input] + state_inputs, outputs=common_outputs)
+             refine_visual_codes_button.click(create_refine_lambda("Codes visuels", visual_codes_input), inputs=common_inputs + [visual_codes_input] + state_inputs, outputs=common_outputs)
+             refine_special_considerations_button.click(create_refine_lambda("Considérations spéciales", special_considerations_input), inputs=common_inputs + [special_considerations_input] + state_inputs, outputs=common_outputs)
+             refine_references_button.click(create_refine_lambda("Références", references_input), inputs=common_inputs + [references_input] + state_inputs, outputs=common_outputs)
+
+
+        # --- Onglet 4 : Résumé du Persona ---
+        with gr.Tab("📄 Étape 4: Résumé du Persona", id=3):
+            gr.Markdown("### 4. Visualisez le persona complet")
+            summary_button = gr.Button("Générer le Résumé du Persona")
+            summary_content = gr.Markdown(elem_classes="persona-summary") # Ajouter une classe pour CSS potentiel
+
+            # Collecter tous les inputs nécessaires pour le résumé
+            all_persona_inputs = [
                 first_name_input, last_name_input, age_input, gender_input, persona_description_input,
                 skin_color_input, eye_color_input, hair_style_input, hair_color_input,
-                facial_expression_input, posture_input,
-                clothing_style_input, accessories_input,
+                facial_expression_input, posture_input, clothing_style_input, accessories_input,
                 marital_status_input, education_level_input, profession_input, income_input,
                 personality_traits_input, values_beliefs_input, motivations_input, hobbies_interests_input,
                 main_responsibilities_input, daily_activities_input, technology_relationship_input,
-                product_related_activities_input, pain_points_input, product_goals_input, persona_image_output
-            ],
-            outputs=summary_content
-        )
-demo.queue().launch(debug=True)
+                product_related_activities_input, pain_points_input, product_goals_input, usage_scenarios_input,
+                brand_relationship_input, market_segment_input, commercial_objectives_input,
+                visual_codes_input, special_considerations_input, daily_life_input, references_input,
+                persona_image_path_state, # Passer l'état contenant le chemin de l'image
+                session_log_state
+            ]
+
+            summary_button.click(
+                 fn=generate_summary_v2,
+                 inputs=all_persona_inputs,
+                 outputs=[summary_content, session_log_state] # Met à jour le contenu et le log
+             )
+
+        # --- Onglet 5 : Journal de Bord ---
+        with gr.Tab("📓 Journal de Bord", id=4):
+            gr.Markdown("### Suivi du Processus de Création")
+            gr.Markdown("Ce journal enregistre les étapes clés de votre session pour faciliter l'analyse et la traçabilité.")
+            log_display_final = gr.Textbox(label="Historique de la session", lines=20, interactive=False)
+            export_log_button_final = gr.Button("Exporter le Journal en .txt")
+            log_file_output = gr.File(label="Télécharger le Journal", file_count="single", visible=False) # Caché initialement
+
+            # Mettre à jour l'affichage du log quand l'état change
+            session_log_state.change(
+                 fn=lambda log_data: log_data,
+                 inputs=session_log_state,
+                 outputs=log_display_final
+            )
+
+            # Fonction pour préparer et retourner le fichier log
+            def export_log_file(log_data):
+                if not log_data:
+                    return gr.update(visible=False)
+                # Créer un fichier texte temporaire
+                with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.txt', encoding='utf-8') as temp_file:
+                    temp_file.write(log_data)
+                    temp_filepath = temp_file.name
+                print(f"Log exporté vers : {temp_filepath}") # Pour debug
+                # Mettre à jour le composant File pour proposer le téléchargement
+                return gr.update(value=temp_filepath, visible=True)
+
+            export_log_button_final.click(
+                fn=export_log_file,
+                inputs=session_log_state,
+                outputs=log_file_output
+            )
+
+# Lancer l'application
+demo.queue().launch(debug=True, share=False) # Share=False par défaut pour sécurité avec clé API