Update app.py

app.py

@@ -1,36 +1,33 @@
 import gradio as gr
 from openai import OpenAI
+import openai # Import top-level for error types
 from pydantic import BaseModel, Field
 import os
 import requests
 from PIL import Image
 import tempfile
-import numpy as np
-import markdown
+import io # For BytesIO
+# import numpy as np # Not strictly needed if using PIL
+import markdown # Required by gr.Markdown implicitly
 import base64
 import datetime
 import json
+import re # For cleaning JSON
 from dotenv import load_dotenv
 
-# --- Configuration ---
+# --- Configuration Initiale ---
 load_dotenv() # Charge les variables depuis un fichier .env s'il existe
 
-api_key = os.getenv("OPENROUTER_API_KEY")
+# Clé OpenRouter (obligatoire pour le fonctionnement de base)
+openrouter_api_key = os.getenv("OPENROUTER_API_KEY")
+OPENROUTER_TEXT_MODEL = "google/gemini-pro-1.5" # Modèle OpenRouter par défaut
+# OPENROUTER_TEXT_MODEL = "google/gemini-flash-1.5" # Alternative plus rapide
 
-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,
-)
-
-MODEL_NAME="google/gemini-2.5-pro-exp-03-25:free"
-
-# --- Modèles Pydantic pour la structuration ---
+# Modèles OpenAI (utilisés si clé fournie)
+OPENAI_TEXT_MODEL = "gpt-4o-mini" # ou "gpt-4o"
+OPENAI_IMAGE_MODEL = "dall-e-3"
 
+# --- Modèles Pydantic (Inchangé) ---
 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.")
@@ -40,10 +37,9 @@ 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 (Mises à jour) ---
 
-# --- Fonctions Utilitaires ---
-
-# Dictionnaires de correspondance (conservés de V1)
+# Dictionnaires de correspondance (Inchangés)
 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"}
@@ -53,27 +49,59 @@ hair_color_mapping = {"": "","Blond": "blonde","Brun": "brown","Noir": "black","
 clothing_style_mapping = {"": "","Décontracté": "casual","Professionnel": "professional","Sportif": "sporty"}
 accessories_mapping = {"": "","Lunettes": "glasses","Montre": "watch","Chapeau": "hat"}
 
-# Fonction de mise à jour du journal
+# Fonction de mise à jour du journal (Limitée et formatée)
+MAX_LOG_LINES = 150
 def update_log(event_description, session_log_state):
+    """Ajoute une entrée au log et le retourne, en limitant sa taille."""
     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 ---
+    current_log = session_log_state if session_log_state else ""
 
-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)
+    # Limiter la taille du log
+    log_lines = current_log.splitlines()
+    # Garde les N dernières lignes
+    if len(log_lines) >= MAX_LOG_LINES:
+        current_log = "\n".join(log_lines[-(MAX_LOG_LINES-1):])
+
+    updated_log = current_log + "\n" + new_log_entry if current_log else new_log_entry
+    return updated_log.strip() # Retourne le log mis à jour
+
+def clean_json_response(raw_response):
+    """Tente d'extraire un bloc JSON valide d'une réponse LLM potentiellement bruitée."""
+    # Recherche d'un bloc JSON marqué par ```json ... ```
+    match = re.search(r"```json\s*({.*?})\s*```", raw_response, re.DOTALL | re.IGNORECASE)
+    if match:
+        return match.group(1)
+    # Recherche d'un objet JSON commençant par { et finissant par }
+    match = re.search(r"({.*?})", raw_response, re.DOTALL)
+    if match:
+        # Essayer de parser pour vérifier si c'est valide
+        try:
+            json.loads(match.group(1))
+            return match.group(1)
+        except json.JSONDecodeError:
+            pass # Si ça échoue, on continue
+
+    # Si rien ne fonctionne, retourne la réponse brute en espérant qu'elle soit déjà du JSON
+    return raw_response.strip()
+
+# --- Fonctions Principales de l'Application (Mises à jour) ---
+
+def analyze_biases_v2(app_config, objective_text, session_log_state):
+    """Analyse les biais dans l'objectif marketing (utilise le client API actif)."""
+    log = session_log_state
+    log = update_log(f"Analyse Biais Objectif (début): '{objective_text[:50]}...'", log)
+
+    if not objective_text:
+         return BiasAnalysisResponse(overall_comment="Veuillez fournir un objectif marketing.").dict(), update_log("Analyse Biais: Objectif vide.", log)
+
+    if not app_config.get("client"):
+        return BiasAnalysisResponse(overall_comment="Erreur: Client API non configuré.").dict(), update_log("ERREUR Analyse Biais: Client non configuré.", log)
+
+    active_client = app_config["client"]
+    model_name = app_config["text_model"]
+
+    # Prompt système V2 (Inchangé)
     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}"
@@ -102,139 +130,206 @@ def analyze_biases_v2(objective_text, session_log_state):
     }}
     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'.
     """
+
+    response_content_str = "" # Init pour le bloc except
     try:
-        completion = client.chat.completions.create(
-            model=MODEL_NAME,
+        completion = active_client.chat.completions.create(
+            model=model_name,
             messages=[
-                {"role": "user", "content": system_prompt} # Intégration de l'objectif dans le prompt système peut être plus robuste pour certains modèles
+                # Note: Certains modèles préfèrent l'objectif dans le message user, d'autres intégré au system prompt.
+                # Ici, on le met dans le system_prompt.
+                {"role": "user", "content": system_prompt}
             ],
             temperature=0.4,
             max_tokens=800,
-            response_format={"type": "json_object"}, # Demander explicitement du JSON si le modèle le supporte bien
+            # Demander explicitement du JSON si le modèle le supporte bien (OpenAI et certains OpenRouter le font)
+            response_format={"type": "json_object"},
         )
 
         response_content_str = completion.choices[0].message.content
-        # Essayer de parser la réponse JSON
-        parsed_response = BiasAnalysisResponse.parse_raw(response_content_str)
-
-        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
-
+        # Nettoyage de la réponse avant parsing
+        cleaned_response_str = clean_json_response(response_content_str)
+
+        # Essayer de parser la réponse JSON nettoyée
+        parsed_response = BiasAnalysisResponse.parse_raw(cleaned_response_str)
+
+        log = update_log(f"Analyse Biais Objectif (fin): Biais trouvés - {len(parsed_response.detected_biases)}", log)
+        return parsed_response.dict(), log
+
+    except openai.AuthenticationError as e:
+         error_msg = f"Erreur d'authentification API ({app_config.get('api_source', 'Inconnu')}). Vérifiez votre clé."
+         print(error_msg)
+         log = update_log(f"ERREUR API Auth: {error_msg}", log)
+         return BiasAnalysisResponse(overall_comment=error_msg).dict(), log
+    except openai.RateLimitError as e:
+         error_msg = f"Erreur API ({app_config.get('api_source', 'Inconnu')}): Limite de taux atteinte. Réessayez plus tard."
+         print(error_msg)
+         log = update_log(f"ERREUR API RateLimit: {error_msg}", log)
+         return BiasAnalysisResponse(overall_comment=error_msg).dict(), log
     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'}"
+        error_msg = f"Erreur pendant l'analyse des biais: {str(e)}. Réponse brute: '{response_content_str[:200]}...'"
         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)
+        log = update_log(f"ERREUR Analyse Biais: {str(e)}", log)
+        # Essayer de retourner une structure d'erreur compatible
+        return BiasAnalysisResponse(overall_comment=f"Erreur technique lors de l'analyse: {str(e)}").dict(), log
 
 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
+    # Prend directement le dict retourné par analyze_biases_v2
+    if not analysis_result:
+        return [("Aucune analyse effectuée.", None)], {} # Retourne format HighlightedText et dict vide
 
     biases = analysis_result.get("detected_biases", [])
     overall_comment = analysis_result.get("overall_comment", "")
 
     highlighted_data = []
-    if not biases:
+    if "Erreur" in overall_comment:
+         highlighted_data.append((overall_comment, "ERROR")) # Étiquette spécifique pour erreurs
+    elif 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)."""
+        if overall_comment:
+            highlighted_data.append((overall_comment + "\n\n", "COMMENT"))
+        for bias_info in biases:
+            highlighted_data.append((f"⚠️ {bias_info.get('bias_type', 'Type inconnu')}: ", "BIAS_TYPE"))
+            highlighted_data.append((f"{bias_info.get('explanation', 'Pas d\'explication.')} ", "EXPLANATION"))
+            highlighted_data.append((f"💡 Conseil: {bias_info.get('advice', 'Pas de conseil.')}\n", "ADVICE"))
+
+    # Retourne les données formatées et le résultat brut (qui est déjà un dict)
+    # Le second output (bias_analysis_result_state) est mis à jour par la fonction appelante si nécessaire
+    return highlighted_data
+
+def generate_persona_image_v2(app_config, *args):
+    """Génère l'image du persona en utilisant OpenAI si activé, sinon retourne None."""
     # 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,
+    log = session_log_state
+    (first_name, last_name, age, gender, persona_description_en, # Renommé pour clarté
      skin_color, eye_color, hair_style, hair_color, facial_expression,
      posture, clothing_style, accessories) = inputs
 
+    # Vérifier si la génération d'image est activée (nécessite clé OpenAI valide)
+    if not app_config.get("image_generation_enabled", False):
+        log = update_log("Génération Image: Désactivée (Clé API OpenAI non fournie/valide).", log)
+        # Retourne None pour l'image et le log mis à jour.
+        # On ajoute aussi un message utilisateur via gr.Info dans le .click
+        return None, log, "Génération d'image désactivée. Veuillez fournir une clé API OpenAI valide dans l'onglet Configuration."
+
+    # Vérifier les champs obligatoires
     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)
+        # Ne pas générer si infos de base manquantes
+        # Le message utilisateur sera géré dans le .click via gr.Info
+        return None, log, "Veuillez remplir Prénom, Nom, Âge et Genre pour générer l'image."
+
+    # Construire le prompt en anglais
+    # Base
+    prompt_parts = [f"one person only, close-up portrait photo of {first_name} {last_name}, a {gender} aged {age}."] # Préciser "photo", "portrait"
+
+    # Détails (utilise les mappings pour traduire les choix FR en termes EN)
+    if skin_color_mapping.get(skin_color): prompt_parts.append(f"Skin tone: {skin_color_mapping[skin_color]}.")
+    if eye_color_mapping.get(eye_color): prompt_parts.append(f"Eye color: {eye_color_mapping[eye_color]}.")
+    if hair_style_mapping.get(hair_style): prompt_parts.append(f"Hairstyle: {hair_style_mapping[hair_style]}.")
+    if hair_color_mapping.get(hair_color): prompt_parts.append(f"Hair color: {hair_color_mapping[hair_color]}.")
+    if facial_expression_mapping.get(facial_expression): prompt_parts.append(f"Facial expression: {facial_expression_mapping[facial_expression]}.")
+    if posture_mapping.get(posture): prompt_parts.append(f"Posture: {posture_mapping[posture]}.")
+    if clothing_style_mapping.get(clothing_style): prompt_parts.append(f"Clothing style: {clothing_style_mapping[clothing_style]}.")
+    if accessories_mapping.get(accessories): prompt_parts.append(f"Wearing: {accessories_mapping[accessories]}.") # "Wearing" est souvent mieux pour les accessoires
+    if persona_description_en: prompt_parts.append(f"Background or context: {persona_description_en}.")
+
+    # Style final
+    prompt_parts.append("Realistic photo style, high detail, natural lighting.")
+    final_prompt = " ".join(prompt_parts)
+
+    log = update_log(f"Génération Image (début): Prompt='{final_prompt[:100]}...'", log)
+
+    # Utiliser le client OpenAI (car image_generation_enabled est True)
+    openai_client = app_config.get("client") # Devrait être le client OpenAI ici
+    if not isinstance(openai_client, OpenAI) or app_config.get("api_source") != "openai":
+         error_msg = "Erreur interne: Tentative de génération d'image sans client OpenAI valide."
+         log = update_log(f"ERREUR Génération Image: {error_msg}", log)
+         return None, log, error_msg
 
     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
+        response = openai_client.images.generate(
+            model=OPENAI_IMAGE_MODEL,
             prompt=final_prompt,
             size="1024x1024",
             n=1,
+            response_format="url", # Ou "b64_json"
+            quality="standard", # ou "hd"
+            style="natural" # ou "vivid"
         )
-        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
 
+        # Traitement de la réponse (URL ou B64)
+        image_url = response.data[0].url
+        # Alternative si b64_json:
+        # img_b64 = response.data[0].b64_json
+        # img_bytes = base64.b64decode(img_b64)
+        # pil_image = Image.open(io.BytesIO(img_bytes))
+
+        # Télécharger l'image depuis l'URL
+        img_response = requests.get(image_url)
+        img_response.raise_for_status() # Vérifie les erreurs HTTP
+
+        # Ouvrir l'image avec PIL depuis les bytes téléchargés
+        pil_image = Image.open(io.BytesIO(img_response.content))
+
+        log = update_log("Génération Image (fin): Succès.", log)
+        # Retourne l'objet PIL Image, le log, et None pour le message d'erreur
+        return pil_image, log, None
+
+    except openai.AuthenticationError as e:
+         error_msg = f"Erreur d'authentification API OpenAI. Vérifiez votre clé."
+         print(error_msg)
+         log = update_log(f"ERREUR API Auth (Image): {error_msg}", log)
+         return None, log, error_msg # Retourne None pour l'image, log, et message d'erreur
+    except openai.RateLimitError as e:
+         error_msg = f"Erreur API OpenAI (Image): Limite de taux atteinte. Réessayez plus tard."
+         print(error_msg)
+         log = update_log(f"ERREUR API RateLimit (Image): {error_msg}", log)
+         return None, log, error_msg
+    except openai.BadRequestError as e: # Erreur fréquente si le prompt est refusé
+         error_msg = f"Erreur API OpenAI (Image): Requête invalide (prompt refusé ?). Détails: {e}"
+         print(error_msg)
+         log = update_log(f"ERREUR API BadRequest (Image): {error_msg}", log)
+         return None, log, error_msg
     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)
+        log = update_log(f"ERREUR Génération Image: {str(e)}", log)
+        return None, log, error_msg
 
-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)."""
+def refine_persona_details_v2(app_config, first_name, last_name, age, field_name, field_value, bias_analysis_json_str, marketing_objectives, session_log_state):
+    """Affine les détails du persona (utilise le client API actif)."""
+    log = session_log_state
+    log = update_log(f"Refinement (début): Champ='{field_name}', Valeur initiale='{field_value[:50]}...'", log)
 
-    log_event_start = f"Refinement (début): Champ='{field_name}', Valeur initiale='{field_value[:50]}...'"
-    update_log(log_event_start, session_log_state)
+    # Vérifier le client API
+    if not app_config.get("client"):
+        error_msg = "Erreur: Client API non configuré pour le raffinement."
+        log = update_log(f"ERREUR Refinement: Client non configuré.", log)
+        # Retourner le log et le message d'erreur pour affichage
+        return log, error_msg
 
-    # 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}"
+    active_client = app_config["client"]
+    model_name = app_config["text_model"]
 
+    # Essayer de récupérer les biais détectés précédemment
+    biases_text = "Aucune analyse de biais précédente disponible ou chargée."
+    if bias_analysis_json_str: # C'est maintenant un dict, pas une str JSON
+        try:
+            # bias_analysis_data = json.loads(bias_analysis_json_str) # Plus nécessaire si c'est un dict
+            detected_biases = bias_analysis_json_str.get("detected_biases", [])
+            if detected_biases:
+                biases_text = "\n".join([f"- {b.get('bias_type','N/A')}: {b.get('explanation','N/A')}" 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 lecture des biais analysés: {e}"
+            log = update_log(f"ERREUR Lecture Biais pour Refinement: {e}", log)
+
+    # Prompt système
     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}"
@@ -242,94 +337,125 @@ def refine_persona_details_v2(first_name, last_name, age, field_name, field_valu
     {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.
+    Propose 1 à 2 suggestions CONCISES et ACTIONNABLES pour améliorer, nuancer ou enrichir cette valeur.
+    Tes suggestions doivent viser à :
+    - Rendre le persona plus r��aliste et moins cliché.
+    - ATTÉNUER spécifiquement les biais potentiels listés ci-dessus s'ils sont pertinents pour ce champ.
+    - Rester cohérent avec l'objectif marketing général.
+    - Éviter les généralisations excessives.
+
+    Si la valeur actuelle semble bonne ou si tu manques de contexte pour faire une suggestion pertinente, indique-le simplement (ex: "La valeur actuelle semble appropriée." ou "Difficile de suggérer sans plus de contexte.").
+    Réponds en français. Ne fournis QUE les suggestions ou le commentaire d'approbation/manque de contexte. Ne répète pas la question.
     """
+    suggestions = "" # Init pour le bloc except
     try:
-        response = client.chat.completions.create(
-            model=MODEL_NAME,
+        response = active_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
+            temperature=0.6, # Un peu plus de créativité pour les suggestions
             max_tokens=150,
         )
         suggestions = response.choices[0].message.content.strip()
 
-        log_event_end = f"Refinement (fin): Champ='{field_name}'. Suggestions: '{suggestions[:50]}...'"
-        update_log(log_event_end, session_log_state)
-
-        # 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
-
+        log = update_log(f"Refinement (fin): Champ='{field_name}'. Suggestions: '{suggestions[:50]}...'", log)
+        # Retourne le log mis à jour et les suggestions (ou None si erreur)
+        return log, suggestions
+
+    except openai.AuthenticationError as e:
+         error_msg = f"Erreur d'authentification API ({app_config.get('api_source', 'Inconnu')}) pendant raffinement. Vérifiez votre clé."
+         print(error_msg)
+         log = update_log(f"ERREUR API Auth (Refine): {error_msg}", log)
+         return log, f"ERREUR: {error_msg}" # Retourne message d'erreur pour affichage
+    except openai.RateLimitError as e:
+         error_msg = f"Erreur API ({app_config.get('api_source', 'Inconnu')}) (Refine): Limite de taux atteinte."
+         print(error_msg)
+         log = update_log(f"ERREUR API RateLimit (Refine): {error_msg}", log)
+         return log, f"ERREUR: {error_msg}"
     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)
+        log = update_log(f"ERREUR Refinement '{field_name}': {str(e)}", log)
+        return log, f"ERREUR: {error_msg}"
 
 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]
+    """Génère le résumé HTML du persona (gestion image PIL)."""
+    # Le dernier arg est session_log_state, l'avant-dernier est persona_image (PIL ou None)
+    inputs = args[:-2] # Tous les champs textuels/numériques/dropdowns
+    persona_image_pil = args[-2] # Peut être None ou un objet PIL Image
     session_log_state = args[-1]
-    (first_name, last_name, age, gender, persona_description,
+    log = session_log_state
+
+    # Extrait tous les champs (assurez-vous que l'ordre correspond à all_persona_inputs_for_summary)
+    (first_name, last_name, age, gender, persona_description_en, # Utiliser la version EN pour le contexte image
      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
+     product_related_activities, pain_points, product_goals, usage_scenarios,
+     brand_relationship, market_segment, commercial_objectives,
+     visual_codes, special_considerations, daily_life, references
      ) = inputs
 
-    log_event = f"Génération Résumé: Pour '{first_name} {last_name}'."
-    update_log(log_event, session_log_state)
+    log = update_log(f"Génération Résumé: Pour '{first_name} {last_name}'.", log)
 
     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"
+        summary += "<h2>Informations de base manquantes</h2>\n"
+        summary += "<p><i>Veuillez fournir au moins le prénom, le nom et l'âge (Étape 2).</i></p>\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):
+        # Intégrer l'image si elle existe (objet PIL)
+        if persona_image_pil and isinstance(persona_image_pil, Image.Image):
             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"
+                # Convertir l'image PIL en base64 pour l'intégrer directement
+                buffered = io.BytesIO()
+                # Sauvegarder en PNG (ou JPEG si préféré) dans le buffer mémoire
+                persona_image_pil.save(buffered, format="PNG")
+                img_bytes = buffered.getvalue()
+                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; margin-top: 10px;'/>\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)
+                img_err_msg = f"Erreur encodage image: {e}"
+                image_html += f"<p><i>{img_err_msg}</i></p>\n"
+                log = update_log(f"ERREUR Encodage Image Résumé: {e}", log)
         else:
-            image_html += "<p>Aucune image générée.</p>\n"
+            image_html += "<p><i>Aucune image générée ou disponible.</i></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"
+        # Utiliser persona_description_en ici car c'est ce qui a été utilisé pour l'image, ou ajouter un champ description générale FR ?
+        # Pour l'instant, on affiche pas la desc EN dans le résumé FR. Ajoutons un champ 'description_persona_fr' ?
+        # Solution simple: ne pas afficher de description ici ou ajouter un nouveau champ.
+        # summary += f"<p><i>{persona_description_en}</i></p>\n" # Commenté
 
         # 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"
+                # N'ajoute que si la valeur existe (n'est pas None, False, 0, ou chaîne vide)
+                if value:
+                    # Formatage spécial pour les revenus
+                    if label == "Revenus annuels (€)" and isinstance(value, (int, float)):
+                        # Format numérique avec séparateur de milliers (espace)
+                        try:
+                           value_str = f"{int(value):,} €".replace(",", " ")
+                        except ValueError: # Gère le cas où income serait une chaîne ou autre chose
+                            value_str = str(value) + " €"
+                    else:
+                        value_str = str(value)
+                    # Remplace les sauts de ligne par <br> pour l'affichage HTML
+                    value_str_html = value_str.replace("\n", "<br>")
+                    content += f"<b>{label}:</b> {value_str_html}<br>\n"
             if content:
-                return f"<h3>{title}</h3>\n{content}<br>\n"
+                # Ajoute un peu d'espace avant la section
+                return f"<h3 style='margin-top: 15px; margin-bottom: 5px; border-bottom: 1px solid #eee; padding-bottom: 2px;'>{title}</h3>\n{content}\n"
             return ""
 
+        # Construire le résumé par sections
         summary += add_section("Infos Socio-Démographiques", {
             "État civil": marital_status, "Niveau d'éducation": education_level,
             "Profession": profession, "Revenus annuels (€)": income
@@ -340,59 +466,177 @@ def generate_summary_v2(*args):
         })
         summary += add_section("Relation au Produit/Service", {
             "Relation avec la technologie": technology_relationship,
-            "Tâches liées au produit": product_related_activities,
+            "Tâches liées au produit/service": product_related_activities,
             "Points de douleur (Pain points)": pain_points,
-            "Objectifs d’utilisation du produit": product_goals,
-            "Scénarios d’utilisation": usage_scenarios
+            "Objectifs d’utilisation du produit/service": product_goals,
+            "Scénarios d’utilisation typiques": 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
+              "Responsabilités principales": main_responsibilities,
+              "Activités journalières": daily_activities,
+              "Une journée type / Citation": daily_life # Renommé pour correspondre au label
         })
         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
+              "Relation avec la marque": brand_relationship,
+              "Segment de marché": market_segment,
+              "Objectifs commerciaux (SMART)": commercial_objectives,
+              "Codes visuels / Marques préférées": visual_codes,
+              "Considérations spéciales (accessibilité, culture...)": 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
+    # Assemblage final avec flexbox pour mettre le texte et l'image côte à côte
+    final_html = "<div style='display: flex; flex-wrap: wrap; align-items: flex-start; font-family: sans-serif; padding: 10px;'>\n"
+    final_html += f"<div style='flex: 1; min-width: 350px; padding-right: 15px;'>\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 ---
+    # Retourne le HTML généré et le log mis à jour
+    return final_html, log
+
+# --- Interface Gradio V2 (Mise à jour avec BYOK et suggestions) ---
+
+with gr.Blocks(theme=gr.themes.Soft(primary_hue="teal", secondary_hue="orange", neutral_hue="slate")) as demo:
+    gr.Markdown("# PersonaGenAI V2 : Assistant de Création de Persona Marketing")
+    gr.Markdown("Outil d'aide à la création de personas, intégrant l'IA générative (OpenRouter ou OpenAI) pour stimuler la créativité et la réflexivité face aux biais.")
+
+    # --- État Global Partagé ---
+    # Stocke la configuration active (client API, modèles, flags)
+    app_config_state = gr.State(value={
+        "client": None,
+        "api_source": None, # 'openai' or 'openrouter'
+        "text_model": None,
+        "image_generation_enabled": False,
+        "openai_key_provided": False,
+        "openrouter_key_provided": bool(openrouter_api_key)
+    })
+    # Stocke le résultat de l'analyse de biais (maintenant un dict)
+    bias_analysis_result_state = gr.State(value={})
+    # Stocke l'image générée (objet PIL ou None)
+    persona_image_pil_state = gr.State(value=None)
+    # Stocke le log de session (chaîne de caractères)
+    session_log_state = gr.State(value="")
+    # Pour afficher les messages d'erreur/status globaux
+    status_message_state = gr.State(value="")
 
-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.")
+    # --- Affichage Global du Statut/Erreur ---
+    status_display = gr.Markdown(value="", elem_classes="status-message") # Pour afficher les messages d'erreur/info
 
-    # --- É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="")
+    # Fonction pour mettre à jour le message de statut
+    def update_status_display(new_message, current_log):
+        # Met aussi à jour le log si un message est affiché
+        if new_message:
+             current_log = update_log(f"STATUS: {new_message}", current_log)
+        return new_message, current_log
 
+    # --- Onglets ---
     with gr.Tabs() as tabs:
 
-        # --- Onglet 0 : Configuration API (Optionnel mais bonne pratique) ---
+        # --- Onglet 0 : Configuration API (BYOK) ---
         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>")
-
+            gr.Markdown("### Configuration des Clés API")
+            gr.Markdown("Cette application utilise une IA pour analyser et générer du contenu. Choisissez votre fournisseur d'API.")
+
+            # Statut de la clé OpenRouter (obligatoire pour le mode de base)
+            if openrouter_api_key:
+                gr.Markdown("✅ Clé API **OpenRouter** trouvée dans l'environnement (`OPENROUTER_API_KEY`).")
+            else:
+                gr.Markdown("❌ **Clé API OpenRouter (`OPENROUTER_API_KEY`) non trouvée.** L'application ne pourra pas fonctionner sans cette clé. Veuillez la définir dans vos variables d'environnement ou un fichier `.env`.")
+
+            # Champ pour la clé OpenAI (optionnelle)
+            openai_api_key_input = gr.Textbox(
+                label="Clé API OpenAI (Optionnelle)",
+                type="password",
+                placeholder="Entrez votre clé OpenAI ici pour activer DALL-E 3 et utiliser OpenAI pour le texte",
+                info="Si fournie, cette clé sera utilisée pour la génération d'images (DALL-E 3) ET pour l'analyse/raffinement de texte (GPT). Sinon, OpenRouter sera utilisé pour le texte et la génération d'images sera désactivée."
+            )
+            # Bouton pour appliquer la config (initialise les clients)
+            configure_api_button = gr.Button("Appliquer la Configuration API")
+            # Affichage du statut de la configuration active
+            api_status_display = gr.Markdown("Statut API: Non configuré.")
+
+            # Fonction de configuration des clients API
+            def configure_api_clients(openai_key, current_config, current_log):
+                openai_key_provided = bool(openai_key)
+                openrouter_key_available = current_config["openrouter_key_provided"]
+                status_msg = ""
+                config = current_config.copy() # Copie pour modification
+
+                client = None
+                api_source = None
+                text_model = None
+                image_enabled = False
+
+                # Priorité à OpenAI si clé fournie
+                if openai_key_provided:
+                    try:
+                        client = OpenAI(api_key=openai_key)
+                        # Faire un petit appel test (optionnel mais recommandé)
+                        # client.models.list() # Peut coûter un peu
+                        api_source = "openai"
+                        text_model = OPENAI_TEXT_MODEL
+                        image_enabled = True
+                        status_msg = f"✅ Configuration **OpenAI** active (Modèle texte: `{text_model}`, Images: DALL-E 3 activé)."
+                        config["openai_key_provided"] = True
+                    except Exception as e:
+                        status_msg = f"⚠️ Clé OpenAI fournie mais invalide ou problème de connexion: {e}. Basculement vers OpenRouter si possible."
+                        log_msg = f"ERREUR API Config OpenAI: {e}"
+                        current_log = update_log(log_msg, current_log)
+                        print(log_msg)
+                        # Reset OpenAI specific flags
+                        config["openai_key_provided"] = False
+                        openai_key_provided = False # Force fallback if error
+
+                # Fallback vers OpenRouter si clé OpenAI non fournie ou invalide, ET si clé OpenRouter existe
+                if not openai_key_provided:
+                    if openrouter_key_available:
+                        try:
+                            client = OpenAI(
+                                base_url="https://openrouter.ai/api/v1",
+                                api_key=openrouter_api_key,
+                            )
+                            api_source = "openrouter"
+                            text_model = OPENROUTER_TEXT_MODEL
+                            image_enabled = False # Image désactivée avec OpenRouter dans cette config
+                            status_msg = f"✅ Configuration **OpenRouter** active (Modèle texte: `{text_model}`, Images: Désactivé)."
+                        except Exception as e:
+                            status_msg = f"❌ Erreur lors de l'initialisation d'OpenRouter: {e}. L'application risque de ne pas fonctionner."
+                            log_msg = f"ERREUR API Config OpenRouter: {e}"
+                            current_log = update_log(log_msg, current_log)
+                            print(log_msg)
+                            client = None # Assure que le client est None
+                    else:
+                        status_msg = "❌ Aucune clé API valide (OpenAI ou OpenRouter) n'est configurée. L'application ne peut pas fonctionner."
+                        client = None # Assure que le client est None
+
+                # Mettre à jour l'état global
+                config["client"] = client
+                config["api_source"] = api_source
+                config["text_model"] = text_model
+                config["image_generation_enabled"] = image_enabled
+
+                log_msg = f"Configuration API appliquée. Source: {api_source or 'Aucune'}, Images: {'Actif' if image_enabled else 'Inactif'}."
+                current_log = update_log(log_msg, current_log)
+
+                # Retourne la nouvelle config, le message de statut, le log mis à jour,
+                # et l'état interactif du bouton de génération d'image
+                return config, status_msg, current_log, gr.update(interactive=image_enabled)
+
+            # Lier le bouton de configuration
+            # La sortie met à jour : l'état de config, le markdown de statut, l'état du log,
+            # et l'interactivité du bouton de génération d'image (qui est dans un autre onglet)
+            # On a besoin de référencer le bouton de génération d'image ici. Il faut le définir avant.
+            # Solution : On va plutôt mettre à jour l'état `app_config_state`, et le bouton d'image
+            # lira cet état quand il sera cliqué. La désactivation visuelle se fera via un .change() sur l'état.
+
+            configure_api_button.click(
+                fn=configure_api_clients,
+                inputs=[openai_api_key_input, app_config_state, session_log_state],
+                outputs=[app_config_state, api_status_display, session_log_state]
+                # L'interactivité du bouton image sera gérée séparément via un .change()
+            )
 
         # --- Onglet 1 : Objectif & Analyse Biais ---
         with gr.Tab("🎯 Étape 1: Objectif & Analyse Biais", id=0):
@@ -401,7 +645,6 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="teal", secondary_hue="orange"))
             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")
@@ -411,7 +654,7 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="teal", secondary_hue="orange"))
             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"}
+                color_map={"BIAS_TYPE": "red", "EXPLANATION": "gray", "ADVICE": "green", "INFO": "blue", "COMMENT": "orange", "ERROR": "darkred"} # Ajout ERROR
             )
             gr.Markdown("---")
             gr.Markdown("### 🤔 Réflexion")
@@ -429,30 +672,33 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="teal", secondary_hue="orange"))
             suggestion_button1.click(lambda: suggestion1_text, outputs=objective_input)
             suggestion_button2.click(lambda: suggestion2_text, outputs=objective_input)
 
+            # Action du bouton Analyser
             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
+                inputs=[app_config_state, objective_input, session_log_state],
+                outputs=[bias_analysis_result_state, session_log_state] # Stocke le dict résultat + maj log
             ).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)
+                fn=display_bias_analysis_v2,
+                inputs=bias_analysis_result_state, # Utilise le résultat stocké (dict)
+                outputs=bias_analysis_output_highlighted # Affiche formaté
             ).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
+                 # Met à jour le statut global si l'analyse a retourné une erreur
+                 fn=lambda result, log: update_status_display(result.get("overall_comment", "") if "Erreur" in result.get("overall_comment", "") else "", log),
+                 inputs=[bias_analysis_result_state, session_log_state],
+                 outputs=[status_display, session_log_state]
             )
 
+            # Action du bouton Enregistrer Réflexion
             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 = update_log(f"Réflexion Utilisateur (Étape 1): '{reflection_text}'", log_state)
+                return log
             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")
@@ -461,28 +707,30 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="teal", secondary_hue="orange"))
                     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)
+                    gender_input = gr.Radio(label="Genre", choices=["Homme", "Femme", "Non-binaire"], value="Homme")
+                    persona_description_en_input = gr.Textbox(label="Contexte/Activité pour l'image (optionnel, en anglais)", lines=1, info="Ex: 'reading a book in a cozy cafe', 'working on a laptop in a modern office', 'hiking on a sunny day'")
 
                     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.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")
+                     # Utiliser type="pil" pour gérer l'image en mémoire
+                    persona_image_output = gr.Image(label="Image du Persona", type="pil", height=400, interactive=False) # Non éditable par l'utilisateur
+                    # Ce bouton sera activé/désactivé par la config API
+                    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 avec discernement pour créer une représentation nuancée et inclusive. La génération d'image nécessite une clé API OpenAI valide (voir onglet Configuration).</small>", elem_classes="warning")
 
             # Logique de l'onglet 2
             visual_inputs = [
@@ -491,144 +739,221 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="teal", secondary_hue="orange"))
             ]
             reset_visuals_button.click(lambda: [""] * len(visual_inputs), outputs=visual_inputs)
 
+            # Action du bouton Générer Image
+            # Définit une fonction intermédiaire pour gérer les sorties multiples et les messages
+            def handle_image_generation(*args):
+                # Le dernier input est app_config_state, l'avant-dernier est log_state
+                # Les autres sont les champs du persona
+                app_config = args[0]
+                log_state = args[-1]
+                persona_inputs = args[1:-1] # first_name, last_name, etc.
+
+                pil_image, updated_log, error_message = generate_persona_image_v2(app_config, *persona_inputs, log_state)
+
+                # Préparer les mises à jour des composants
+                status_update = error_message if error_message else "" # Message pour le statut global
+                # Si infos manquantes (retournées par generate_persona.. comme error_message)
+                if "Veuillez remplir" in (error_message or ""):
+                    gr.Info(error_message) # Affiche un popup Gradio Info
+                    status_update = "" # Ne pas mettre dans le statut global
+
+                # Si génération désactivée (aussi retourné comme error_message)
+                if "Génération d'image désactivée" in (error_message or ""):
+                    gr.Info(error_message) # Affiche popup
+                    status_update = "" # Ne pas mettre dans le statut global
+
+                return pil_image, updated_log, status_update
+
             generate_image_button.click(
-                fn=generate_persona_image_v2,
-                inputs=[
-                    first_name_input, last_name_input, age_input, gender_input, persona_description_input,
+                fn=handle_image_generation,
+                inputs=[app_config_state] + [ # Passer l'état de config en premier
+                    first_name_input, last_name_input, age_input, gender_input, persona_description_en_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
+                    session_log_state # Passer l'état du log en dernier
                 ],
-                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
+                outputs=[
+                    persona_image_pil_state, # Met à jour l'état de l'image (PIL ou None)
+                    session_log_state,    # Met à jour l'état du log
+                    status_message_state  # Met à jour l'état du message (pour affichage global)
+                ]
+            ).then( # Chaîne pour mettre à jour l'affichage de l'image depuis l'état
+                 fn=lambda img_state: img_state,
+                 inputs=persona_image_pil_state,
+                 outputs=persona_image_output
+            ).then( # Chaîne pour mettre à jour l'affichage du statut depuis l'état
+                 fn=lambda status_state, log_state: update_status_display(status_state, log_state),
+                 inputs=[status_message_state, session_log_state],
+                 outputs=[status_display, session_log_state]
             )
 
+            # Mettre à jour l'interactivité du bouton quand la config API change
+            app_config_state.change(
+                 fn=lambda config: gr.update(interactive=config.get("image_generation_enabled", False)),
+                 inputs=app_config_state,
+                 outputs=generate_image_button
+            )
 
         # --- 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)
+            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", lines=2, scale=4, info="Ex: early adopter, prudent, technophobe, pragmatique...")
+                        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 intermédiaire pour gérer l'appel de raffinement et l'affichage
+            def handle_refinement_request(app_config, fname, lname, age_val, field_name_display, field_val, bias_state, objectives, log_state):
+                # Appel de la fonction de raffinement
+                updated_log, result = refine_persona_details_v2(app_config, fname, lname, age_val, field_name_display, field_val, bias_state, objectives, log_state)
+
+                # Afficher le résultat (suggestions ou erreur)
+                if result and "ERREUR:" in result:
+                    # Afficher dans le statut global si c'est une erreur API
+                    status_update = result
+                    gr.Warning(f"Erreur lors du raffinement pour '{field_name_display}'. Vérifiez le log.")
+                elif result:
+                    # Afficher les suggestions dans une InfoBox
+                    gr.Info(f"Suggestions pour '{field_name_display}':\n{result}")
+                    status_update = "" # Pas d'erreur à afficher globalement
+                else:
+                    # Cas où result est None ou vide (ne devrait pas arriver mais au cas où)
+                     status_update = ""
+                     gr.Warning(f"Pas de suggestion reçue pour '{field_name_display}'.")
+
+                return updated_log, status_update
+
+            # Fonction lambda générique pour appeler le handler de raffinement
+            def create_refine_handler(field_name_display, input_component):
+                 # Le lambda prend les inputs requis par handle_refinement_request
+                return lambda app_conf, fname, lname, age_val, field_val, bias_state, objectives, log_state: \
+                    handle_refinement_request(app_conf, fname, lname, age_val, field_name_display, field_val, bias_state, objectives, log_state)
+
+            # Lier chaque bouton "Affiner"
+            common_inputs_refine = [app_config_state, first_name_input, last_name_input, age_input]
+            state_inputs_refine = [bias_analysis_result_state, objective_input, session_log_state]
+            # La sortie met à jour le log et potentiellement le message de statut global
+            common_outputs_refine = [session_log_state, status_message_state]
+
+            # Lier tous les boutons
+            refine_buttons_map = {
+                refine_personality_traits_button: ("Traits de personnalité", personality_traits_input),
+                refine_values_beliefs_button: ("Valeurs et croyances", values_beliefs_input),
+                refine_motivations_button: ("Motivations", motivations_input),
+                refine_hobbies_interests_button: ("Loisirs et intérêts", hobbies_interests_input),
+                refine_technology_relationship_button: ("Relation avec la technologie", technology_relationship_input),
+                refine_product_related_activities_button: ("Tâches liées au produit", product_related_activities_input),
+                refine_pain_points_button: ("Points de douleur", pain_points_input),
+                refine_product_goals_button: ("Objectifs produit", product_goals_input),
+                refine_usage_scenarios_button: ("Scénarios d'utilisation", usage_scenarios_input),
+                refine_main_responsibilities_button: ("Responsabilités principales", main_responsibilities_input),
+                refine_daily_activities_button: ("Activités journalières", daily_activities_input),
+                refine_daily_life_button: ("Journée type/Citation", daily_life_input),
+                refine_brand_relationship_button: ("Relation marque", brand_relationship_input),
+                refine_market_segment_button: ("Segment marché", market_segment_input),
+                refine_commercial_objectives_button: ("Objectifs commerciaux", commercial_objectives_input),
+                refine_visual_codes_button: ("Codes visuels", visual_codes_input),
+                refine_special_considerations_button: ("Considérations spéciales", special_considerations_input),
+                refine_references_button: ("Références", references_input),
+            }
+
+            for btn, (label, input_comp) in refine_buttons_map.items():
+                btn.click(
+                    fn=create_refine_handler(label, input_comp),
+                    inputs=common_inputs_refine + [input_comp] + state_inputs_refine,
+                    outputs=common_outputs_refine
+                 ).then( # Chaîne pour mettre à jour l'affichage du statut depuis l'état
+                     fn=lambda status_state, log_state: update_status_display(status_state, log_state),
+                     inputs=[status_message_state, session_log_state],
+                     outputs=[status_display, session_log_state]
+                 )
 
 
         # --- 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
+            # Utiliser Markdown pour afficher le HTML du résumé
+            summary_content = gr.Markdown(elem_classes="persona-summary", value="Cliquez sur 'Générer' pour voir le résumé.")
 
-            # 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,
+            # Collecter tous les inputs nécessaires pour le résumé DANS LE BON ORDRE pour generate_summary_v2
+            all_persona_inputs_for_summary = [
+                first_name_input, last_name_input, age_input, gender_input, persona_description_en_input, # Input EN utilisé pour l'image
                 skin_color_input, eye_color_input, hair_style_input, hair_color_input,
                 facial_expression_input, posture_input, clothing_style_input, accessories_input,
                 marital_status_input, education_level_input, profession_input, income_input,
@@ -637,48 +962,79 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="teal", secondary_hue="orange"))
                 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
+                # Ajouter les états nécessaires en dernier
+                persona_image_pil_state, # Passer l'état contenant l'image PIL
                 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
-             )
+                fn=generate_summary_v2,
+                inputs=all_persona_inputs_for_summary,
+                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)
+            gr.Markdown("Ce journal enregistre les étapes clés et les erreurs de votre session.")
+            log_display_final = gr.Textbox(label="Historique de la session", lines=20, interactive=False, max_lines=MAX_LOG_LINES)
             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
+            # Utiliser gr.DownloadButton pour une meilleure UX
+            # log_file_output = gr.File(label="Télécharger le Journal", file_count="single", visible=False) # Caché initialement
+            download_log_button = gr.DownloadButton(label="Télécharger le Journal", visible=False)
+
 
             # 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
+                fn=lambda log_data: log_data,
+                inputs=session_log_state,
+                outputs=log_display_final
+            )
+
+            # Mettre à jour l'affichage global du statut quand l'état change
+            status_message_state.change(
+                 fn=lambda status_msg, log: update_status_display(status_msg, log),
+                 inputs=[status_message_state, session_log_state],
+                 outputs=[status_display, session_log_state]
             )
 
-            # Fonction pour préparer et retourner le fichier log
-            def export_log_file(log_data):
+            # Fonction pour préparer le fichier log pour le DownloadButton
+            def prepare_log_for_download(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)
+                    return gr.update(visible=False) # Cache le bouton si pas de log
+
+                # Créer un fichier texte temporaire que Gradio peut servir
+                # Utiliser delete=False car Gradio doit pouvoir lire le fichier après le retour de la fonction
+                try:
+                    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"Fichier log prêt pour téléchargement : {temp_filepath}")
+                    # Retourner le chemin pour le DownloadButton et le rendre visible
+                    # Note: Gradio est censé gérer le nettoyage de ce fichier temporaire.
+                    return gr.update(value=temp_filepath, visible=True)
+                except Exception as e:
+                    print(f"Erreur création fichier log pour téléchargement: {e}")
+                    return gr.update(visible=False) # Cache le bouton en cas d'erreur
 
             export_log_button_final.click(
-                fn=export_log_file,
+                fn=prepare_log_for_download,
                 inputs=session_log_state,
-                outputs=log_file_output
+                outputs=download_log_button
             )
 
 # Lancer l'application
-demo.queue().launch(debug=True, share=False) # Share=False par défaut pour sécurité avec clé API
+# Utiliser queue() pour gérer les appels API potentiellement longs
+# debug=True est utile pour le développement, False en production
+# share=False est plus sûr par défaut, surtout avec des clés API
+if not openrouter_api_key:
+     print("\n" + "="*60)
+     print("ERREUR CRITIQUE : Clé API OpenRouter non trouvée.")
+     print("Veuillez définir OPENROUTER_API_KEY dans votre environnement.")
+     print("L'application ne fonctionnera pas correctement sans elle.")
+     print("="*60 + "\n")
+     # On pourrait arrêter ici, mais on lance quand même Gradio pour voir l'interface
+     # et permettre la configuration OpenAI si l'utilisateur le souhaite.
+     # Cependant, l'état initial sera non fonctionnel sans config valide.
+
+demo.queue().launch(debug=False, share=False)