Update app.py

app.py

@@ -1,3 +1,4 @@
+# --- Imports and Initial Config (mostly unchanged) ---
 import gradio as gr
 from openai import OpenAI
 import openai # Import top-level for error types
@@ -27,7 +28,7 @@ OPENROUTER_TEXT_MODEL = "google/gemini-pro-1.5" # Modèle OpenRouter par défaut
 OPENAI_TEXT_MODEL = "gpt-4o-mini" # ou "gpt-4o"
 OPENAI_IMAGE_MODEL = "dall-e-3"
 
-# --- Modèles Pydantic (Inchangé) ---
+# --- Pydantic Models (Unchanged) ---
 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.")
@@ -37,8 +38,8 @@ 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 (Unchanged, except maybe clean_json if needed later) ---
+# ... (update_log, clean_json_response, mappings remain the same) ...
 # 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"}
@@ -73,35 +74,98 @@ def clean_json_response(raw_response):
     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
+    # More robust search: find the first '{' and the last '}'
+    start = raw_response.find('{')
+    end = raw_response.rfind('}')
+    if start != -1 and end != -1 and end > start:
+        potential_json = raw_response[start:end+1]
         try:
-            json.loads(match.group(1))
-            return match.group(1)
+            json.loads(potential_json)
+            return potential_json
         except json.JSONDecodeError:
-            pass # Si ça échoue, on continue
+             # Attempt to fix common issues like trailing commas (simple case)
+            cleaned = re.sub(r",\s*([}\]])", r"\1", potential_json)
+            try:
+                 json.loads(cleaned)
+                 return cleaned
+            except json.JSONDecodeError:
+                 pass # Give up on this match
 
-    # Si rien ne fonctionne, retourne la réponse brute en espérant qu'elle soit déjà du JSON
+    # If nothing works, return the raw response hoping it's already JSON or error handled elsewhere
     return raw_response.strip()
 
+
+# --- Holder for Active API Clients (Keep outside gr.Blocks) ---
+# This avoids storing complex objects in gr.State, which causes the TypeError
+active_api_client_holder = {
+    "client": None,
+    "openai_key": None # Store the validated key here temporarily if needed
+}
+
 # --- Fonctions Principales de l'Application (Mises à jour) ---
 
+def get_active_client(app_config):
+    """Retrieves the globally stored client based on app_config."""
+    api_source = app_config.get("api_source")
+    if not api_source:
+        return None, "API source not configured."
+
+    client = active_api_client_holder.get("client")
+
+    # Check if the stored client matches the configured source
+    if client:
+        if api_source == "openai" and not isinstance(client, OpenAI):
+             # Check if it's the OpenRouter client mistakenly stored
+             # This check might need refinement based on how you differentiate clients
+             pass # Assume it's correct for now, relies on configure_api_clients logic
+        elif api_source == "openrouter" and not client.base_url.startswith("https://openrouter.ai"):
+             pass # Assume it's correct
+
+    if not client:
+         # Attempt to re-initialize if missing (e.g., after script reload)
+         print("WARN: Active client not found in holder, attempting re-initialization based on config.")
+         if api_source == "openai" and active_api_client_holder.get("openai_key"):
+             try:
+                 client = OpenAI(api_key=active_api_client_holder["openai_key"])
+                 active_api_client_holder["client"] = client
+                 print("Re-initialized OpenAI client.")
+             except Exception as e:
+                 return None, f"Failed to re-initialize OpenAI client: {e}"
+         elif api_source == "openrouter" and openrouter_api_key:
+             try:
+                 client = OpenAI(
+                     base_url="https://openrouter.ai/api/v1",
+                     api_key=openrouter_api_key,
+                 )
+                 active_api_client_holder["client"] = client
+                 print("Re-initialized OpenRouter client.")
+             except Exception as e:
+                  return None, f"Failed to re-initialize OpenRouter client: {e}"
+         else:
+              return None, f"Cannot re-initialize client for source '{api_source}'. Missing key or config."
+
+
+    if not client:
+         return None, f"API client for '{api_source}' is not available or failed to initialize."
+
+    return client, None # Return client and no error message
+
 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)
+        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, error_msg = get_active_client(app_config)
+    if error_msg:
+        log = update_log(f"ERREUR Analyse Biais: {error_msg}", log)
+        return BiasAnalysisResponse(overall_comment=f"Erreur: {error_msg}").dict(), log
 
-    active_client = app_config["client"]
     model_name = app_config["text_model"]
 
-    # Prompt système V2 (Inchangé)
+    # --- System Prompt (Unchanged) ---
     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}"
@@ -131,60 +195,63 @@ def analyze_biases_v2(app_config, 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
+    response_content_str = "" # Init for the bloc except
     try:
         completion = active_client.chat.completions.create(
             model=model_name,
             messages=[
-                # 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}
+                 {"role": "user", "content": system_prompt}
             ],
             temperature=0.4,
             max_tokens=800,
-            # 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
-        # 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)
+        # Try parsing the cleaned JSON response
+        try:
+            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 Exception as parse_error:
+             error_msg = f"Erreur parsing JSON après nettoyage: {parse_error}. Réponse nettoyée: '{cleaned_response_str[:200]}...'"
+             print(error_msg)
+             log = update_log(f"ERREUR Analyse Biais Parsing: {parse_error}", log)
+             return BiasAnalysisResponse(overall_comment=f"Erreur technique lors du parsing de la réponse: {parse_error}").dict(), log
 
-        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
+        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
+        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[:200]}...'"
         print(error_msg)
-        log = update_log(f"ERREUR Analyse Biais: {str(e)}", log)
-        # Essayer de retourner une structure d'erreur compatible
+        log = update_log(f"ERREUR Analyse Biais API Call: {str(e)}", log)
+        # Try to return a compatible error structure
         return BiasAnalysisResponse(overall_comment=f"Erreur technique lors de l'analyse: {str(e)}").dict(), log
 
+# --- display_bias_analysis_v2 (Unchanged) ---
 def display_bias_analysis_v2(analysis_result):
     """Formate l'analyse des biais pour l'affichage avec 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
+        return [("Aucune analyse effectuée.", None)] # Retourne format HighlightedText
 
     biases = analysis_result.get("detected_biases", [])
     overall_comment = analysis_result.get("overall_comment", "")
 
     highlighted_data = []
     if "Erreur" in overall_comment:
-         highlighted_data.append((overall_comment, "ERROR")) # Étiquette spécifique pour erreurs
+        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:
@@ -195,10 +262,10 @@ def display_bias_analysis_v2(analysis_result):
             highlighted_data.append((f"{bias_info.get('explanation', 'Pas d’explication.')}\n", "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
+    # Retourne les données formatées pour HighlightedText
     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
@@ -212,21 +279,22 @@ def generate_persona_image_v2(app_config, *args):
     # 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."
 
+    # Get the active OpenAI client (Image generation always uses OpenAI in this app)
+    # We assume configure_api_clients stored the *correct* client if image_gen is enabled
+    openai_client, error_msg = get_active_client(app_config)
+    if error_msg or app_config.get("api_source") != "openai":
+         final_error = f"Erreur interne ou mauvaise config pour Génération Image: {error_msg or 'Client non OpenAI actif'}"
+         log = update_log(f"ERREUR Génération Image: {final_error}", log)
+         return None, log, final_error
+
     # Vérifier les champs obligatoires
     if not first_name or not last_name or not age or not gender:
-        # 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
+    # --- Build Prompt (Unchanged) ---
     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]}.")
@@ -236,20 +304,11 @@ def generate_persona_image_v2(app_config, *args):
     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 = openai_client.images.generate(
             model=OPENAI_IMAGE_MODEL,
@@ -261,79 +320,70 @@ def generate_persona_image_v2(app_config, *args):
             style="natural" # ou "vivid"
         )
 
-        # 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
+        return pil_image, log, None # Image, Log, No error message
 
+    # --- Error Handling (Unchanged) ---
     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
+        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
+        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
+        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)
         log = update_log(f"ERREUR Génération Image: {str(e)}", log)
         return None, log, error_msg
 
-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):
+
+def refine_persona_details_v2(app_config, first_name, last_name, age, field_name, field_value, bias_analysis_dict, marketing_objectives, session_log_state):
     """Affine les détails du persona (utilise le client API actif)."""
+    # Note: bias_analysis_json_str is now bias_analysis_dict
     log = session_log_state
     log = update_log(f"Refinement (début): Champ='{field_name}', Valeur initiale='{field_value[:50]}...'", log)
 
-    # 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
+    # Get active client
+    active_client, error_msg = get_active_client(app_config)
+    if error_msg:
+        log = update_log(f"ERREUR Refinement: {error_msg}", log)
+        return log, f"ERREUR: {error_msg}" # Return log and error message
 
-    active_client = app_config["client"]
     model_name = app_config["text_model"]
 
-    # Essayer de récupérer les biais détectés précédemment
+    # Process bias analysis results (now expects a dict)
     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
+    if bias_analysis_dict:
         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", [])
+            detected_biases = bias_analysis_dict.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."
+                biases_text = bias_analysis_dict.get("overall_comment", "Aucun biais majeur détecté lors de l'analyse initiale.") # Use overall comment if no biases
         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)
+            biases_text = f"Erreur lors de la lecture des biais analysés (dict): {e}"
+            log = update_log(f"ERREUR Lecture Biais Dict pour Refinement: {e}", log)
+
 
-    # Prompt système
+    # --- System Prompt (Unchanged, uses biases_text) ---
     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 :
+    L'analyse initiale de cet objectif a soulevé les points suivants :
     {biases_text}
 
     Tâche: Concentre-toi UNIQUEMENT sur le champ '{field_name}' dont la valeur actuelle est '{field_value}'.
@@ -347,7 +397,7 @@ def refine_persona_details_v2(app_config, first_name, last_name, age, field_name
     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
+    suggestions = "" # Init for the bloc except
     try:
         response = active_client.chat.completions.create(
             model=model_name,
@@ -358,25 +408,27 @@ def refine_persona_details_v2(app_config, first_name, last_name, age, field_name
         suggestions = response.choices[0].message.content.strip()
 
         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 updated log and suggestions (or None if error)
         return log, suggestions
 
+    # --- Error Handling (Unchanged) ---
     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
+        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}" # Return error message for display
     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}"
+        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)
         log = update_log(f"ERREUR Refinement '{field_name}': {str(e)}", log)
         return log, f"ERREUR: {error_msg}"
 
+# --- generate_summary_v2 (Unchanged, already handles PIL image correctly) ---
 def generate_summary_v2(*args):
     """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)
@@ -413,10 +465,15 @@ def generate_summary_v2(*args):
                 # 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")
+                # Handle potential RGBA issues for JPEG
+                img_to_save = persona_image_pil
+                if img_to_save.mode == 'RGBA' or 'transparency' in img_to_save.info:
+                     img_to_save = img_to_save.convert('RGB') # Convert to RGB if it has alpha
+
+                img_to_save.save(buffered, format="JPEG") # Use JPEG for smaller size usually
                 img_bytes = buffered.getvalue()
                 img_base64 = base64.b64encode(img_bytes).decode()
-                img_data_url = f"data:image/png;base64,{img_base64}"
+                img_data_url = f"data:image/jpeg;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:
                 img_err_msg = f"Erreur encodage image: {e}"
@@ -427,9 +484,6 @@ def generate_summary_v2(*args):
 
         # Section Informations Personnelles (Titre centré)
         summary += f"<div style='text-align: center;'><h1>{first_name} {last_name}, {age} ans ({gender})</h1></div>\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)
@@ -437,18 +491,27 @@ def generate_summary_v2(*args):
             content = ""
             for label, value in fields.items():
                 # N'ajoute que si la valeur existe (n'est pas None, False, 0, ou chaîne vide)
-                if value:
+                # Exception for income == 0 which might be valid
+                should_add = False
+                if label == "Revenus annuels (€)":
+                    # Add if value is not None (0 is a valid income)
+                    should_add = value is not None
+                elif value: # Standard check for other fields
+                     should_add = True
+
+                if should_add:
                     # 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(",", " ")
+                            # Use non-breaking space for thousands separator in HTML
+                            value_str = f"{int(value):,} €".replace(",", "&nbsp;")
                         except ValueError: # Gère le cas où income serait une chaîne ou autre chose
-                            value_str = str(value) + " €"
+                            value_str = str(value) + "&nbsp;€"
                     else:
                         value_str = str(value)
-                    # Remplace les sauts de ligne par <br> pour l'affichage HTML
-                    value_str_html = value_str.replace("\n", "<br>")
+                    # Remplace les sauts de ligne par <br> pour l'affichage HTML, escape HTML chars
+                    value_str_html = markdown.markdown(value_str).replace('<p>', '').replace('</p>', '').strip().replace("\n", "<br>")
                     content += f"<b>{label}:</b> {value_str_html}<br>\n"
             if content:
                 # Ajoute un peu d'espace avant la section
@@ -472,30 +535,31 @@ def generate_summary_v2(*args):
             "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 type / Citation": daily_life # Renommé pour correspondre au label
+             "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,
-              "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
+             "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 pour mettre le texte et l'image côte à côte
+    # Assemblage final avec flexbox
     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>"
 
-    # Retourne le HTML généré et le log mis à jour
+    # Return the generated HTML and updated log
     return final_html, log
 
+
 # --- Interface Gradio V2 (Mise à jour avec BYOK et suggestions) ---
 
 with gr.Blocks(theme=gr.themes.Glass()) as demo:
@@ -503,18 +567,18 @@ with gr.Blocks(theme=gr.themes.Glass()) as demo:
     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)
+    # Stocke la configuration active (flags, modèle, mais PAS le client objet)
     app_config_state = gr.State(value={
-        "client": None,
+        # "client": None, # REMOVED - DO NOT STORE CLIENT OBJECT IN STATE
         "api_source": None, # 'openai' or 'openrouter'
         "text_model": None,
         "image_generation_enabled": False,
-        "openai_key_provided": False,
+        "openai_key_provided": False, # Flag if key was entered
         "openrouter_key_provided": bool(openrouter_api_key)
     })
-    # Stocke le résultat de l'analyse de biais (maintenant un dict)
+    # Stocke le résultat de l'analyse de biais (dict)
     bias_analysis_result_state = gr.State(value={})
-    # Stocke l'image générée (objet PIL ou None)
+    # Stocke l'image générée (objet PIL ou None) - Keep this, gr.Image handles PIL
     persona_image_pil_state = gr.State(value=None)
     # Stocke le log de session (chaîne de caractères)
     session_log_state = gr.State(value="")
@@ -528,7 +592,9 @@ with gr.Blocks(theme=gr.themes.Glass()) as demo:
     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)
+            # Avoid logging redundant "success" messages or empty updates
+            if "ERREUR" in new_message or "WARN" in new_message or ("Configuration" in new_message and "active" in new_message) :
+                 current_log = update_log(f"STATUS: {new_message}", current_log)
         return new_message, current_log
 
     # --- Onglets ---
@@ -543,99 +609,138 @@ with gr.Blocks(theme=gr.themes.Glass()) as demo:
             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`.")
+                gr.Markdown("❌ **Clé API OpenRouter (`OPENROUTER_API_KEY`) non trouvée.** Le mode OpenRouter ne fonctionnera pas. Veuillez la définir dans vos variables d'environnement ou un fichier `.env` (ou utiliser une clé OpenAI).")
 
             # 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."
+                info="Si fournie et valide, 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 (si clé dispo) 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
+            # Fonction de configuration des clients API (modifiée)
             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
+                # Clear previous client and stored key from holder
+                active_api_client_holder["client"] = None
+                active_api_client_holder["openai_key"] = None
+
                 api_source = None
                 text_model = None
                 image_enabled = False
+                client_to_store = None # The client object we will put in the global holder
 
                 # 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
+                        temp_client = OpenAI(api_key=openai_key)
+                        # Simple test call (optional but good)
+                        temp_client.models.list(limit=1) # Less expensive test
+
+                        # If test succeeds:
+                        client_to_store = temp_client
+                        active_api_client_holder["openai_key"] = openai_key # Store key if needed for re-init
                         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
+                        current_log = update_log("Configuration: Client OpenAI initialisé et testé.", current_log)
+
+                    except openai.AuthenticationError:
+                         status_msg = "⚠️ Clé API OpenAI fournie mais **invalide**. Vérifiez la clé."
+                         log_msg = f"ERREUR API Config OpenAI: Clé invalide."
+                         current_log = update_log(log_msg, current_log)
+                         print(log_msg)
+                         config["openai_key_provided"] = False
+                         openai_key_provided = False # Force fallback check
                     except Exception as e:
-                        status_msg = f"⚠️ Clé OpenAI fournie mais invalide ou problème de connexion: {e}. Basculement vers OpenRouter si possible."
+                        status_msg = f"⚠️ Clé OpenAI fournie mais erreur de connexion/test: {str(e)}. Vérifiez la clé et la connectivité."
                         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
+                        openai_key_provided = False # Force fallback check
 
                 # 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
+                # Use 'elif' to avoid configuring OpenRouter if OpenAI was successful
+                elif openrouter_key_available:
+                    try:
+                        temp_client = OpenAI(
+                            base_url="https://openrouter.ai/api/v1",
+                            api_key=openrouter_api_key,
+                        )
+                        # Simple test (e.g., list models - adapt if needed for OpenRouter structure)
+                        # temp_client.models.list(limit=1) # Might need adjustment based on OpenRouter API/latency
+
+                        client_to_store = temp_client
+                        api_source = "openrouter"
+                        text_model = OPENROUTER_TEXT_MODEL
+                        image_enabled = False # Image désactivée avec OpenRouter
+                        status_msg = f"✅ Configuration **OpenRouter** active (Modèle texte: `{text_model}`, Images: Désactivé)."
+                        config["openai_key_provided"] = False # Ensure this is false
+                        current_log = update_log("Configuration: Client OpenRouter initialisé.", current_log)
 
-                # Mettre à jour l'état global
-                config["client"] = client
+                    except Exception as e:
+                        status_msg = f"❌ Erreur lors de l'initialisation d'OpenRouter (clé: {openrouter_api_key is not None}): {e}."
+                        log_msg = f"ERREUR API Config OpenRouter: {e}"
+                        current_log = update_log(log_msg, current_log)
+                        print(log_msg)
+                        client_to_store = None # Ensure no client is stored
+                        api_source = None
+                        text_model = None
+                        image_enabled = False
+                        config["openai_key_provided"] = False
+
+                else: # No valid OpenAI key provided AND no OpenRouter key available
+                     if not openai_key_provided and not openrouter_key_available:
+                          status_msg = "❌ Aucune clé API valide (ni OpenAI ni OpenRouter) n'est disponible/configurée. L'application ne peut pas fonctionner."
+                     elif not openrouter_key_available: # OpenAI key was provided but failed, and no OpenRouter fallback
+                          status_msg += " Et aucune clé OpenRouter n'est disponible comme alternative." # Append to previous OpenAI error msg
+                     else: # Should not happen given the logic, but as a safeguard
+                          status_msg = "❌ Impossible de configurer un client API."
+
+                     client_to_store = None # Ensure no client is stored
+                     api_source = None
+                     text_model = None
+                     image_enabled = False
+                     config["openai_key_provided"] = False
+
+
+                # Store the successfully created client (or None) in the global holder
+                active_api_client_holder["client"] = client_to_store
+
+                # Mettre à jour l'état global (config flags only)
+                # config["client"] = client_to_store # DO NOT STORE CLIENT IN STATE
                 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)
+                log_msg = f"Configuration API appliquée. Source Active: {api_source or 'Aucune'}, Images: {'Actif' if image_enabled else 'Inactif'}."
+                # Avoid double logging if already logged above
+                if "Configuration:" not in log_msg:
+                    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)
+                # Return the new config state dict, the status message, and the updated log
+                # The interactivity update is handled by the .change() on app_config_state
+                return config, status_msg, current_log
 
-            # 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.
 
+            # Link the configuration button
+            # Outputs: update app_config_state, api_status_display markdown, session_log_state
             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 ---
@@ -676,22 +781,24 @@ with gr.Blocks(theme=gr.themes.Glass()) as demo:
             analyze_button.click(
                 fn=analyze_biases_v2,
                 inputs=[app_config_state, objective_input, session_log_state],
-                outputs=[bias_analysis_result_state, session_log_state] # Stocke le dict résultat + maj log
+                outputs=[bias_analysis_result_state, session_log_state] # Stores the result dict + updates log
             ).then(
                 fn=display_bias_analysis_v2,
-                inputs=bias_analysis_result_state, # Utilise le résultat stocké (dict)
-                outputs=bias_analysis_output_highlighted # Affiche formaté
+                inputs=bias_analysis_result_state, # Uses the stored result (dict)
+                outputs=bias_analysis_output_highlighted # Displays formatted output
             ).then(
-                 # 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]
+                # Updates the global status display only if the analysis returned an error message
+                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):
-                log = update_log(f"Réflexion Utilisateur (Étape 1): '{reflection_text}'", log_state)
-                return log
+                if reflection_text: # Only log if there's text
+                     log = update_log(f"Réflexion Utilisateur (Étape 1): '{reflection_text}'", log_state)
+                     return log
+                return log_state # Return unchanged log if input is empty
             log_reflection_button.click(
                 fn=log_user_reflection,
                 inputs=[user_reflection_on_biases, session_log_state],
@@ -703,7 +810,8 @@ with gr.Blocks(theme=gr.themes.Glass()) as demo:
         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
+                # FIX: Changed scale to integer
+                with gr.Column(scale=1): # Colonne de gauche pour les inputs (adjust scale integer as needed)
                     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)
@@ -726,11 +834,11 @@ with gr.Blocks(theme=gr.themes.Glass()) as demo:
                         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
-                     # Utiliser type="pil" pour gérer l'image en mémoire
+                    # Use type="pil" to handle image in memory
                     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")
+                    # This button's interactivity is controlled by app_config_state.change()
+                    generate_image_button = gr.Button("🖼️ Générer / Mettre à jour l'Image", interactive=False) # Start disabled
+                    gr.Markdown("<small>💡 **Attention :** Les IA génératrices d'images peuvent reproduire des stéréotypes. Utilisez les détails visuels avec discernement. 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 = [
@@ -740,73 +848,79 @@ with gr.Blocks(theme=gr.themes.Glass()) as demo:
             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
+            # Defines an intermediate function to handle multiple outputs and 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
+                # The first input is app_config_state, the last is log_state
+                # The others are the persona fields
                 app_config = args[0]
                 log_state = args[-1]
                 persona_inputs = args[1:-1] # first_name, last_name, etc.
 
+                # Call the generation function (which now gets client via get_active_client)
                 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
+                # Prepare component updates
+                status_update_msg = "" # Message for the global status display
+                info_popup_msg = None # Message for gr.Info popup
+
+                if error_message:
+                    if "Veuillez remplir" in error_message or "Génération d'image désactivée" in error_message:
+                        info_popup_msg = error_message # Use popup for user guidance
+                    else:
+                        status_update_msg = error_message # Use global status for API/internal errors
 
-                # 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
+                # Show popup if needed
+                if info_popup_msg:
+                     gr.Info(info_popup_msg)
 
-                return pil_image, updated_log, status_update
+                # Return the PIL image (or None), the updated log, and the status message string
+                return pil_image, updated_log, status_update_msg
 
+            # Connect the button click
             generate_image_button.click(
                 fn=handle_image_generation,
-                inputs=[app_config_state] + [ # Passer l'état de config en premier
+                inputs=[app_config_state] + [ # Pass config state first
                     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 en dernier
+                    session_log_state # Pass log state last
                 ],
                 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)
+                    persona_image_pil_state, # Update the PIL image state
+                    session_log_state,       # Update the log state
+                    status_message_state     # Update the status message state
                 ]
-            ).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]
+            ).then( # Chain to update the image display from the state
+                fn=lambda img_state: img_state,
+                inputs=persona_image_pil_state,
+                outputs=persona_image_output
+            ).then( # Chain to update the global status display from the state
+                fn=update_status_display, # Use the existing update function
+                inputs=[status_message_state, session_log_state],
+                outputs=[status_display, session_log_state]
             )
 
-            # Mettre à jour l'interactivité du bouton quand la config API change
+            # Update button interactivity when API config changes
             app_config_state.change(
-                 fn=lambda config: gr.update(interactive=config.get("image_generation_enabled", False)),
-                 inputs=app_config_state,
-                 outputs=generate_image_button
+                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é
+            # Organize into sections
             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)
+                    income_input = gr.Number(label="Revenus annuels (€)", minimum=0, step=1000) # Allow 0
 
                     gr.Markdown("#### Psychographie")
                     with gr.Row(equal_height=False):
@@ -840,7 +954,7 @@ with gr.Blocks(theme=gr.themes.Glass()) as demo:
                         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
+            # Other optional fields
             with gr.Accordion("Autres Informations (Optionnel)", open=False):
                 with gr.Row():
                     with gr.Column():
@@ -877,40 +991,42 @@ with gr.Blocks(theme=gr.themes.Glass()) as demo:
                             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
+            # Intermediate function to handle refinement requests and display results
+            def handle_refinement_request(app_config, fname, lname, age_val, field_name_display, field_val, bias_state_dict, objectives, log_state):
+                # Call the refinement function
+                updated_log, result = refine_persona_details_v2(app_config, fname, lname, age_val, field_name_display, field_val, bias_state_dict, objectives, log_state)
+
+                status_update_msg = "" # For global status
+                # Display the result (suggestions or error)
+                if result:
+                     if "ERREUR:" in result:
+                          # Show API/internal errors in global status and as a warning popup
+                          status_update_msg = result
+                          gr.Warning(f"Erreur lors du raffinement pour '{field_name_display}'. Vérifiez le log et le statut.")
+                     else:
+                          # Show suggestions in an Info popup
+                          gr.Info(f"Suggestions pour '{field_name_display}':\n{result}")
+                          # No need to update global status for successful suggestions
                 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}'.")
+                    # Case where result is None or empty
+                    gr.Warning(f"Pas de suggestion reçue pour '{field_name_display}'.")
 
-                return updated_log, status_update
+                return updated_log, status_update_msg
 
-            # Fonction lambda générique pour appeler le handler de raffinement
+            # Generic lambda function to call the refinement handler
             def create_refine_handler(field_name_display, input_component):
-                 # Le lambda prend les inputs requis par handle_refinement_request
+                # The lambda takes the inputs required by 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"
+            # Link each "Refine" button
             common_inputs_refine = [app_config_state, first_name_input, last_name_input, age_input]
+            # Pass the bias_analysis_result_state (which holds the dict)
             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
+            # Outputs update the log and potentially the global status message state
             common_outputs_refine = [session_log_state, status_message_state]
 
-            # Lier tous les boutons
+            # Map buttons to their corresponding input component and label
             refine_buttons_map = {
                 refine_personality_traits_button: ("Traits de personnalité", personality_traits_input),
                 refine_values_beliefs_button: ("Valeurs et croyances", values_beliefs_input),
@@ -937,23 +1053,23 @@ with gr.Blocks(theme=gr.themes.Glass()) as demo:
                     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),
+                ).then( # Chain to update the global status display from the state
+                     fn=update_status_display,
                      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")
-            # Utiliser Markdown pour afficher le HTML du résumé
+            # Use Markdown to display the HTML summary
             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é DANS LE BON ORDRE pour generate_summary_v2
+            # Collect all inputs for the summary IN THE CORRECT ORDER for 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
+                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,
                 marital_status_input, education_level_input, profession_input, income_input,
@@ -962,79 +1078,110 @@ with gr.Blocks(theme=gr.themes.Glass()) as demo:
                 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,
-                # Ajouter les états nécessaires en dernier
-                persona_image_pil_state, # Passer l'état contenant l'image PIL
+                # Add necessary states last
+                persona_image_pil_state, # Pass the state containing the PIL image
                 session_log_state
             ]
 
             summary_button.click(
                 fn=generate_summary_v2,
                 inputs=all_persona_inputs_for_summary,
-                outputs=[summary_content, session_log_state] # Met à jour le contenu et le log
+                outputs=[summary_content, session_log_state] # Updates content and 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 et les erreurs de votre session.")
+            gr.Markdown("Ce journal enregistre les étapes clés, les réflexions 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")
-            # 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)
-
+            # Use gr.DownloadButton for better UX
+            download_log_button = gr.DownloadButton(label="Télécharger le Journal", visible=False) # Hidden initially
 
-            # Mettre à jour l'affichage du log quand l'état change
+            # Update log display when state changes
             session_log_state.change(
                 fn=lambda log_data: log_data,
                 inputs=session_log_state,
-                outputs=log_display_final
+                outputs=log_display_final,
+                # Add queue=False to make UI update instantly for log
+                # queue=False # Might cause issues if log updates very rapidly? Test.
             )
 
-            # 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]
-            )
+            # Update global status display when its state changes
+            # This might be redundant if status updates always accompany log updates, but safe to keep
+            # status_message_state.change(
+            #     fn=update_status_display,
+            #     inputs=[status_message_state, session_log_state],
+            #     outputs=[status_display, session_log_state]
+            # )
 
-            # Fonction pour préparer le fichier log pour le DownloadButton
+            # Function to prepare the log file for the DownloadButton
+            # Keep this outside the click if possible, or ensure it's fast
             def prepare_log_for_download(log_data):
                 if not log_data:
-                    return gr.update(visible=False) # Cache le bouton si pas de log
+                    return gr.update(visible=False) # Keep button hidden if no 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:
+                    # Create a temporary text file Gradio can serve
                     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 the path for the DownloadButton and make it visible
+                    # Gradio is supposed to handle cleanup.
                     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
+                    # Update status display with error?
+                    # update_status_display(f"Erreur export log: {e}", log_data) # Careful with state updates here
+                    return gr.update(visible=False) # Keep button hidden on error
+
+
+            # Instead of a separate export button, trigger preparation when log changes? Or use DownloadButton directly?
+            # Let's use the DownloadButton's direct file generation capability if possible.
+
+            # Simpler approach: Directly provide the generating function to DownloadButton
+            def generate_log_content(log_data):
+                 if not log_data:
+                      return None # Or raise an error? Gradio might handle None better.
+                 # Return the content directly, Gradio handles file creation
+                 filename = f"personagenai_log_{datetime.datetime.now().strftime('%Y%m%d_%H%M%S')}.txt"
+                 # Must return a file path or bytes/BytesIO
+                 log_bytes = log_data.encode('utf-8')
+                 temp_file = io.BytesIO(log_bytes)
+                 temp_file.name = filename # Suggest a filename
+                 # Returning BytesIO might not work directly with gr.DownloadButton value generation
+                 # Let's stick to the NamedTemporaryFile approach, triggered by a separate button
+
+            # Re-add the export button to trigger the file prep
+            export_log_button_final = gr.Button("Préparer l'Export du Journal")
 
             export_log_button_final.click(
-                fn=prepare_log_for_download,
-                inputs=session_log_state,
-                outputs=download_log_button
+                 fn=prepare_log_for_download,
+                 inputs=session_log_state,
+                 outputs=download_log_button # Update the DownloadButton (makes visible, sets path)
             )
 
-# Lancer l'application
-# 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
+
+# --- Launch App ---
+# Initial check for OpenRouter key
 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)
+    print("\n" + "="*60)
+    print("AVERTISSEMENT : Clé API OpenRouter (`OPENROUTER_API_KEY`) non trouvée.")
+    print("Le fonctionnement dépendra de la fourniture d'une clé OpenAI valide.")
+    print("="*60 + "\n")
+    # Initialize app_config_state accordingly in the Gradio definition?
+    # The initial state already reflects this with "openrouter_key_provided": False
+
+# Set initial API status message based on initial config possibilities
+initial_api_status = "Statut API: Non configuré."
+if openrouter_api_key:
+     # Attempt to configure OpenRouter by default if key exists
+     print("Clé OpenRouter trouvée, tentative de configuration initiale...")
+     initial_config, initial_api_status, initial_log = configure_api_clients(None, app_config_state.value, "")
+     app_config_state.value = initial_config # Update initial state value
+     session_log_state.value = initial_log
+     print(initial_api_status) # Print status to console
+     # We need to update the Markdown display default value too
+     api_status_display.value = initial_api_status # Set initial value for the Markdown component
+
+demo.queue().launch(debug=False, share=False) # debug=True helpful for development