Update app.py

app.py

@@ -7,8 +7,12 @@ import traceback # Ajout pour afficher les tracebacks complets
 
 from flask import Flask, request, session, jsonify, redirect, url_for, flash, render_template
 from dotenv import load_dotenv
+# Importe genai et types séparément pour plus de clarté
 from google import genai
-from google.genai import types # Important pour Part, FileData, etc.
+from google.genai import types # Important pour Part, FileData, SafetySetting etc.
+# L'exception StopCandidateException est directement sous genai
+# from google.generativeai.types import StopCandidateException # Ne fonctionne pas
+
 import requests
 from werkzeug.utils import secure_filename
 import markdown # Pour convertir la réponse Markdown en HTML
@@ -39,14 +43,13 @@ print(f"Dossier d'upload configuré : {os.path.abspath(UPLOAD_FOLDER)}")
 
 # --- Configuration de l'API Gemini ---
 # Utilisez les noms de modèles spécifiés
-MODEL_FLASH = 'gemini-2.0-flash' # Mis à jour
-MODEL_PRO = 'gemini-2.5-pro-exp-03-25' # Mis à jour - Pro est souvent nécessaire/meilleur pour la vidéo
+MODEL_FLASH = 'gemini-2.0-flash'
+MODEL_PRO = 'gemini-2.5-pro-exp-03-25' # Pro est souvent nécessaire/meilleur pour la vidéo
 
 # Instruction système pour le modèle
 SYSTEM_INSTRUCTION = "Tu es un assistant intelligent et amical nommé Mariam. Tu assistes les utilisateurs au mieux de tes capacités, y compris dans l'analyse de texte, d'images et de vidéos (via upload ou lien YouTube). Tu as été créé par Aenir."
 
-# Paramètres de sécurité (ajuster si nécessaire)
-# Utilisation de la structure attendue par GenerateContentConfig
+# Paramètres de sécurité (structure correcte pour GenerateContentConfig)
 SAFETY_SETTINGS_CONFIG = [
     types.SafetySetting(
       category=types.HarmCategory.HARM_CATEGORY_HATE_SPEECH,
@@ -68,28 +71,23 @@ SAFETY_SETTINGS_CONFIG = [
 
 
 GEMINI_CONFIGURED = False
-gemini_client = None # Client API pour les opérations sur les fichiers (upload vidéo)
+gemini_client = None # Client API
 
 try:
     gemini_api_key = os.getenv("GOOGLE_API_KEY")
     if not gemini_api_key:
         raise ValueError("Clé API GOOGLE_API_KEY manquante dans le fichier .env")
 
-    # Initialise le client pour les opérations sur les fichiers ET pour lister les modèles
+    # Initialise le client
     gemini_client = genai.Client(api_key=gemini_api_key)
-    # Configure également l'espace de noms global pour GenerativeModel, etc. (Peut être redondant si client est utilisé)
-    # genai.configure(api_key=gemini_api_key)
 
-    # Vérifie si les modèles requis sont disponibles en utilisant le client (Correction: client.models.list())
+    # Vérifie si les modèles requis sont disponibles en utilisant le client
     print("Vérification des modèles Gemini disponibles...")
-    # Note: l'API liste les modèles sans le préfixe 'models/', on l'ajoute pour la comparaison
-    available_models_full_names = [m.name for m in gemini_client.models.list()]
-    required_models_prefixes = [MODEL_FLASH, MODEL_PRO] # Noms courts
-    # Vérifie si les modèles requis (commençant par les noms courts) existent dans la liste complète
+    available_models_full_names = [m.name for m in gemini_client.models.list()] # Correction: client.models.list()
+    required_models_prefixes = [MODEL_FLASH, MODEL_PRO]
     models_found = {req: False for req in required_models_prefixes}
     for available in available_models_full_names:
         for req in required_models_prefixes:
-            # Vérifie si le nom disponible commence par 'models/' suivi du nom requis
             if available.startswith(f'models/{req}'):
                 models_found[req] = True
 
@@ -104,9 +102,10 @@ try:
 
 except Exception as e:
     print(f"ERREUR Critique lors de la configuration initiale de Gemini : {e}")
+    traceback.print_exc() # Affiche le traceback pour l'erreur d'init
     print("L'application fonctionnera sans les fonctionnalités IA.")
-    gemini_client = None # S'assure que le client est None si la config échoue
-    GEMINI_CONFIGURED = False # S'assurer qu'il est False en cas d'erreur
+    gemini_client = None
+    GEMINI_CONFIGURED = False
 
 # --- Fonctions Utilitaires ---
 
@@ -124,94 +123,74 @@ def is_video_file(filename):
 
 def is_youtube_url(url):
     """Vérifie si la chaîne ressemble à une URL YouTube valide."""
-    if not url: # Gère les cas où l'URL est None ou vide
-        return False
-    # Regex simple pour les formats courants d'URL YouTube
+    if not url: return False
     youtube_regex = re.compile(
-        r'(https?://)?(www.)?' # Protocole et www optionnels
-        r'(youtube|youtu|youtube-nocookie).(com|be)/' # Domaines youtube.com, youtu.be, etc.
-        r'(watch?v=|embed/|v/|.+?v=)?' # Différents chemins possibles
-        r'([^&=%\?]{11})') # L'ID vidéo de 11 caractères
+        r'(https?://)?(www.)?'
+        r'(youtube|youtu|youtube-nocookie).(com|be)/'
+        r'(watch?v=|embed/|v/|.+?v=)?'
+        r'([^&=%\?]{11})')
     return youtube_regex.match(url) is not None
 
 # --- Fonction d'Upload Vidéo avec Polling ---
 
 def upload_video_with_polling(filepath, mime_type, max_wait_seconds=300, poll_interval=10):
-    """
-    Upload une vidéo via client.files.upload et attend son traitement.
-    Retourne l'objet File traité ou lève une exception.
-    """
+    """Upload une vidéo via client.files.upload et attend son traitement."""
     if not gemini_client:
         raise ConnectionError("Le client Gemini n'est pas initialisé.")
 
     print(f"Début de l'upload vidéo via client.files: {filepath} ({mime_type})")
-    video_file = None # Initialise la variable pour le bloc finally
+    video_file = None
     try:
-        # Lance l'upload
         video_file = gemini_client.files.upload(path=filepath, mime_type=mime_type)
         print(f"Upload initialisé. Nom du fichier distant: {video_file.name}. Attente du traitement...")
 
         start_time = time.time()
-        # Boucle de polling tant que l'état est "PROCESSING"
-        while video_file.state == types.FileState.PROCESSING: # Utilise types.FileState
+        while video_file.state == types.FileState.PROCESSING:
             elapsed_time = time.time() - start_time
-            # Vérifie le timeout
             if elapsed_time > max_wait_seconds:
                 raise TimeoutError(f"Le traitement de la vidéo a dépassé le délai de {max_wait_seconds} secondes.")
-
             print(f"Vidéo en cours de traitement... (État: {video_file.state.name}, {int(elapsed_time)}s écoulées)")
             time.sleep(poll_interval)
-            # Récupère l'état mis à jour du fichier
             video_file = gemini_client.files.get(name=video_file.name)
 
-        # Vérifie l'état final après la boucle
-        if video_file.state == types.FileState.FAILED: # Utilise types.FileState
+        if video_file.state == types.FileState.FAILED:
             print(f"ERREUR: Le traitement de la vidéo a échoué. État: {video_file.state.name}")
             raise ValueError("Le traitement de la vidéo a échoué côté serveur.")
-
-        if video_file.state == types.FileState.ACTIVE: # Utilise types.FileState
+        if video_file.state == types.FileState.ACTIVE:
             print(f"Traitement vidéo terminé avec succès: {video_file.uri}")
-            return video_file # Retourne l'objet fichier SDK réussi
-
+            return video_file
         else:
-            # Gère d'autres états inattendus si nécessaire
             print(f"AVERTISSEMENT: État inattendu du fichier vidéo après traitement: {video_file.state.name}")
             raise RuntimeError(f"État inattendu du fichier vidéo: {video_file.state.name}")
 
     except Exception as e:
         print(f"Erreur lors de l'upload/traitement vidéo via client.files: {e}")
-        # Tente de supprimer le fichier distant en cas d'erreur pendant le polling/upload
         if video_file and hasattr(video_file, 'name'):
             try:
                 gemini_client.files.delete(name=video_file.name)
                 print(f"Tentative de nettoyage du fichier distant {video_file.name} après erreur.")
             except Exception as delete_err:
                  print(f"Échec du nettoyage du fichier distant {video_file.name} après erreur: {delete_err}")
-        raise # Relance l'exception originale pour qu'elle soit gérée par l'appelant
+        raise
 
 # --- Fonctions de Recherche Web (inchangées - implémentez si nécessaire) ---
 
 def perform_web_search(query):
-    """Effectue une recherche web via l'API Serper (Exemple)."""
     serper_api_key = os.getenv("SERPER_API_KEY")
     if not serper_api_key:
         print("AVERTISSEMENT: Clé API SERPER_API_KEY manquante. Recherche web désactivée.")
         return None
-    # ... (votre implémentation de la recherche Serper) ...
     print(f"Recherche Web (simulation) pour : {query}")
-    # Simuler des résultats pour le test
-    # return {"organic": [{"title": "Résultat Web 1", "link": "#", "snippet": "Description du résultat 1..."}]}
-    return None # Désactivé par défaut
+    return None
 
 def format_search_results(data):
-    """Met en forme les résultats de recherche (Exemple)."""
     if not data: return "Aucun résultat de recherche web pertinent."
-    # ... (votre implémentation du formatage) ...
     results = ["Résultats Web:"]
     if data.get('organic'):
         for item in data['organic'][:3]:
             results.append(f"- {item.get('title', '')}: {item.get('snippet', '')}")
         return "\n".join(results)
+    return "Aucun résultat organique trouvé."
 
 # --- Préparation Historique (Corrigé pour utiliser types.Part) ---
 
@@ -219,15 +198,11 @@ def prepare_gemini_history(chat_history):
     """Convertit l'historique de session pour l'API Gemini (texte seulement)."""
     gemini_history = []
     for message in chat_history:
-        # Ne transmet que le texte brut des messages précédents
         role = 'user' if message['role'] == 'user' else 'model'
-        raw_text_content = message.get('raw_text', '') # Utilise raw_text stocké
-
-        # Ne pas inclure les fichiers/médias des tours précédents pour simplifier
-        if raw_text_content: # N'ajoute que s'il y a du texte
+        raw_text_content = message.get('raw_text', '')
+        if raw_text_content:
             # Correction: Créer un objet Part pour le texte
             text_part_object = types.Part(text=raw_text_content)
-            # Ajouter le dictionnaire avec le rôle et la liste contenant l'objet Part
             gemini_history.append({'role': role, 'parts': [text_part_object]})
     return gemini_history
 
@@ -236,45 +211,36 @@ def prepare_gemini_history(chat_history):
 @app.route('/')
 def root():
     """Sert la page HTML principale."""
-    # Assurez-vous d'avoir un fichier templates/index.html
     try:
         return render_template('index.html')
     except Exception as e:
-        # Retourne une erreur simple si le template n'est pas trouvé
         print(f"Erreur lors du rendu du template index.html: {e}")
         return "Erreur: Impossible de charger la page principale. Vérifiez que 'templates/index.html' existe.", 500
 
-
 @app.route('/api/history', methods=['GET'])
 def get_history():
     """Fournit l'historique de chat (formaté pour affichage) en JSON."""
     if 'chat_history' not in session:
         session['chat_history'] = []
-
-    # Prépare l'historique pour l'affichage (contient le HTML pour l'assistant)
     display_history = [
         {'role': msg.get('role', 'unknown'), 'text': msg.get('text', '')}
         for msg in session.get('chat_history', [])
     ]
-    # print(f"API: Récupération historique ({len(display_history)} messages)") # Debug
     return jsonify({'success': True, 'history': display_history})
 
 @app.route('/api/chat', methods=['POST'])
 def chat_api():
     """Gère les requêtes de chat (texte, fichier/vidéo uploadé, URL YouTube)."""
-    # Vérifie si Gemini est configuré correctement
     if not GEMINI_CONFIGURED or not gemini_client:
         print("API ERREUR: Tentative d'appel à /api/chat sans configuration Gemini valide.")
         return jsonify({'success': False, 'error': "Le service IA n'est pas configuré correctement."}), 503
 
-    # --- Récupération des données du formulaire ---
     prompt = request.form.get('prompt', '').strip()
-    youtube_url = request.form.get('youtube_url', '').strip() # Récupère le champ YouTube dédié
+    youtube_url = request.form.get('youtube_url', '').strip()
     use_web_search = request.form.get('web_search', 'false').lower() == 'true'
     use_advanced = request.form.get('advanced_reasoning', 'false').lower() == 'true'
-    file = request.files.get('file') # Récupère le fichier uploadé
+    file = request.files.get('file')
 
-    # --- Validation de l'entrée (au moins un type d'input requis) ---
     if not file and not youtube_url and not prompt:
         return jsonify({'success': False, 'error': 'Veuillez fournir un message, un fichier/vidéo ou un lien YouTube.'}), 400
 
@@ -284,179 +250,123 @@ def chat_api():
     print(f"  URL YouTube: {youtube_url if youtube_url else 'Non'}")
     print(f"  Web Search: {use_web_search}, Advanced: {use_advanced}")
 
-    # Initialise l'historique de session si nécessaire
     if 'chat_history' not in session:
         session['chat_history'] = []
 
-    # --- Variables pour le traitement ---
-    uploaded_media_part = None           # Part(file_data=...) pour Gemini
-    uploaded_filename_for_display = None # Nom à afficher dans le chat user
-    filepath_to_delete = None            # Chemin du fichier temporaire à supprimer
-    is_media_request = False             # True si fichier ou URL YT est l'input principal
-    media_type = None                    # 'file', 'video', 'youtube', ou 'text'
+    uploaded_media_part = None
+    uploaded_filename_for_display = None
+    filepath_to_delete = None
+    is_media_request = False
+    media_type = None
 
-    # --- Traitement de l'entrée (Priorité: Fichier > YouTube > Texte) ---
     try:
-        # 1. Traiter le fichier uploadé s'il existe
         if file and file.filename != '':
             is_media_request = True
-            media_type = 'file' # Par défaut, pourrait devenir 'video'
+            media_type = 'file'
             uploaded_filename_for_display = secure_filename(file.filename)
-
             if not allowed_file(uploaded_filename_for_display):
                 raise ValueError(f"Type de fichier non autorisé: {uploaded_filename_for_display}")
 
-            # Sauvegarde temporaire du fichier
             filepath = os.path.join(app.config['UPLOAD_FOLDER'], uploaded_filename_for_display)
             file.save(filepath)
-            filepath_to_delete = filepath # Marque pour suppression future
+            filepath_to_delete = filepath
             print(f"  Fichier '{uploaded_filename_for_display}' sauvegardé -> '{filepath}'")
             mime_type = mimetypes.guess_type(filepath)[0] or 'application/octet-stream'
 
-            # Utilise le polling pour les vidéos, upload direct pour les autres
             if is_video_file(uploaded_filename_for_display):
                 media_type = 'video'
                 print("  Traitement VIDÉO Uploadée (avec polling)...")
-                # Appel bloquant qui attend le traitement
                 processed_media_file = upload_video_with_polling(filepath, mime_type)
-                # Crée le Part Gemini à partir de l'objet File retourné
-                uploaded_media_part = types.Part(file_data=processed_media_file) # Utilise types.Part
+                uploaded_media_part = types.Part(file_data=processed_media_file)
             else:
-                print("  Traitement FICHIER standard...")
-                # Utilise l'upload global plus simple pour les non-vidéos
-                # Note: genai.upload_file n'existe pas directement, utiliser client.files.upload
-                # S'il s'agit d'une image ou autre fichier non-vidéo, l'upload avec polling peut
-                # retourner rapidement si le traitement est rapide, ou on peut simplifier.
-                # Utilisons le client ici aussi pour la cohérence.
-                print(f"  Upload via client.files pour fichier non-vidéo: {filepath}")
+                print("  Traitement FICHIER standard via client.files...")
                 processed_media_file = gemini_client.files.upload(path=filepath, mime_type=mime_type)
-                # Pas besoin de polling complexe ici en général, on suppose que c'est rapide.
-                # On peut ajouter un petit wait ou une vérification simple si nécessaire.
-                # Attente très courte pour s'assurer que l'état passe à ACTIVE (simplifié)
-                time.sleep(2)
+                time.sleep(2) # Attente simplifiée
                 processed_media_file = gemini_client.files.get(name=processed_media_file.name)
                 if processed_media_file.state != types.FileState.ACTIVE:
-                     print(f"AVERTISSEMENT: Fichier non-vidéo '{processed_media_file.name}' n'est pas ACTIF après upload ({processed_media_file.state.name}). Tentative de continuer.")
-                     # On pourrait lever une erreur ici si l'état ACTIVE est crucial
-                     # raise RuntimeError(f"Échec de l'activation du fichier {processed_media_file.name}")
-
-                uploaded_media_part = types.Part(file_data=processed_media_file) # Utilise types.Part
+                     print(f"AVERTISSEMENT: Fichier non-vidéo '{processed_media_file.name}' n'est pas ACTIF ({processed_media_file.state.name}).")
+                uploaded_media_part = types.Part(file_data=processed_media_file)
             print(f"  Part Média ({media_type}) créé: {processed_media_file.uri}")
 
-        # 2. Sinon, traiter l'URL YouTube si fournie et valide
         elif youtube_url:
              if not is_youtube_url(youtube_url):
-                 print(f"  AVERTISSEMENT: '{youtube_url}' n'est pas un lien YouTube valide, sera ignoré ou traité comme texte si prompt vide.")
-                 media_type = 'text' # Considéré comme texte simple si invalide
+                 print(f"  AVERTISSEMENT: '{youtube_url}' n'est pas un lien YouTube valide.")
+                 media_type = 'text'
              else:
                 is_media_request = True
                 media_type = 'youtube'
                 print("  Traitement LIEN YouTube...")
-                uploaded_filename_for_display = youtube_url # Affiche l'URL pour l'utilisateur
-                youtube_uri = youtube_url # Utilise l'URL validée comme URI
-                # Crée un Part FileData directement à partir de l'URI
-                uploaded_media_part = types.Part( # Utilise types.Part
-                    file_data=types.FileData(file_uri=youtube_uri, mime_type="video/mp4") # Utilise types.FileData
+                uploaded_filename_for_display = youtube_url
+                youtube_uri = youtube_url
+                uploaded_media_part = types.Part(
+                    file_data=types.FileData(file_uri=youtube_uri, mime_type="video/mp4")
                 )
                 print(f"  Part YouTube créé pour: {youtube_uri}")
                 if not prompt:
                     prompt = "Décris ou analyse le contenu de cette vidéo YouTube."
                     print(f"  Prompt par défaut ajouté pour YouTube: '{prompt}'")
 
-        # 3. Si ni fichier ni URL YT valide, c'est une requête texte
         elif prompt:
             media_type = 'text'
             print("  Traitement PROMPT texte seul.")
         else:
-            raise ValueError("Aucune entrée valide (fichier, URL YouTube ou texte) fournie.")
+            raise ValueError("Aucune entrée valide fournie.")
 
-        # --- Préparer et stocker le message utilisateur dans l'historique ---
         display_user_text = prompt
         if media_type == 'file' or media_type == 'video':
             display_user_text = f"[{uploaded_filename_for_display}]" + (f" {prompt}" if prompt else "")
         elif media_type == 'youtube':
              display_user_text = f"[YouTube]" + (f" {prompt}" if prompt else "") + f"\n{uploaded_filename_for_display}"
 
-        user_history_entry = {
-            'role': 'user',
-            'text': display_user_text,
-            'raw_text': prompt
-        }
+        user_history_entry = {'role': 'user', 'text': display_user_text, 'raw_text': prompt}
         session['chat_history'].append(user_history_entry)
         session.modified = True
 
-        # --- Préparer les 'parts' pour l'appel API Gemini ---
         current_gemini_parts = []
         if uploaded_media_part:
             current_gemini_parts.append(uploaded_media_part)
 
         final_prompt_for_gemini = prompt
-
         if use_web_search and prompt and media_type == 'text':
             print("  Activation Recherche Web...")
             search_data = perform_web_search(prompt)
             if search_data:
                 formatted_results = format_search_results(search_data)
-                final_prompt_for_gemini = f"""Basé sur la question suivante et les informations web ci-dessous, fournis une réponse complète.
-
-    Question Originale:
-    "{prompt}"
-
-    Informations Web Pertinentes:
-    --- DEBUT RESULTATS WEB ---
-    {formatted_results}
-    --- FIN RESULTATS WEB ---
-
-    Réponse:"""
+                final_prompt_for_gemini = f"""Basé sur la question suivante et les informations web ci-dessous, fournis une réponse complète.\n\nQuestion Originale:\n"{prompt}"\n\nInformations Web Pertinentes:\n--- DEBUT RESULTATS WEB ---\n{formatted_results}\n--- FIN RESULTATS WEB ---\n\nRéponse:"""
                 print("  Prompt enrichi avec les résultats web.")
             else:
                 print("  Aucun résultat de recherche web trouvé ou pertinent.")
 
         if final_prompt_for_gemini:
-             # Correction: Toujours créer un objet Part pour le texte
-             current_gemini_parts.append(types.Part(text=final_prompt_for_gemini)) # Utilise types.Part
+             current_gemini_parts.append(types.Part(text=final_prompt_for_gemini)) # Correction: Toujours Part
 
         if not current_gemini_parts:
-             print("ERREUR: Aucune partie (média ou texte) à envoyer à Gemini.")
              raise ValueError("Impossible de traiter la requête : contenu vide.")
 
-        # --- Appel à l'API Gemini ---
         gemini_history = prepare_gemini_history(session['chat_history'][:-1])
+        # Structure correcte pour contents (liste de dictionnaires role/parts)
         contents_for_gemini = gemini_history + [{'role': 'user', 'parts': current_gemini_parts}]
 
-        # Sélectionne le modèle : Pro pour média ou si avancé demandé, sinon Flash
-        # Préfixe 'models/' nécessaire pour l'API generate_content
-        selected_model = f'models/{MODEL_PRO}' if is_media_request or use_advanced else f'models/{MODEL_FLASH}'
-        print(f"  Modèle sélectionné pour l'API: {selected_model}")
-
-        # Crée l'instance de configuration
-        generation_config = types.GenerationConfig(
-            # candidate_count=1, # Optionnel: demander une seule réponse
-            # stop_sequences=["..."], # Optionnel
-            # max_output_tokens=..., # Optionnel
-            # temperature=..., # Optionnel
-            # top_p=..., # Optionnel
-            # top_k=..., # Optionnel
-        )
+        selected_model_api_name = f'models/{MODEL_PRO}' if is_media_request or use_advanced else f'models/{MODEL_FLASH}'
+        print(f"  Modèle sélectionné pour l'API: {selected_model_api_name}")
+
+        generation_config = types.GenerationConfig() # Config vide par défaut, ajouter des params si besoin
 
-        # Appel API (Correction: utilise 'model', non 'model_name')
-        # Utilisation de la méthode generate_content sur le client
-        print(f"  Envoi de la requête à {selected_model} ({len(contents_for_gemini)} messages/tours)...")
-        response = gemini_client.generate_content(
-            model=selected_model, # Correction: utilise 'model'
+        # Correction: Appel via client.models.generate_content
+        print(f"  Envoi de la requête à {selected_model_api_name} ({len(contents_for_gemini)} messages/tours)...")
+        response = gemini_client.models.generate_content(
+            model=selected_model_api_name, # Utilise 'model'
             contents=contents_for_gemini,
-            generation_config=generation_config, # Passe l'objet config
-            safety_settings=SAFETY_SETTINGS_CONFIG, # Passe les safety settings
-            system_instruction=types.Content(parts=[types.Part(text=SYSTEM_INSTRUCTION)], role="system") # Instruction système formatée
+            generation_config=generation_config,
+            safety_settings=SAFETY_SETTINGS_CONFIG,
+            system_instruction=types.Content(parts=[types.Part(text=SYSTEM_INSTRUCTION)], role="system")
         )
 
-
-        # --- Traitement de la Réponse ---
         response_text_raw = ""
         response_html = ""
         try:
              response_text_raw = response.text
-        except ValueError as ve: # Typiquement levé si la réponse est bloquée
+        except ValueError as ve:
             print(f"  ERREUR: La réponse de Gemini a été bloquée (ValueError): {ve}")
             try:
                 print(f"  Détails du blocage (Prompt Feedback): {response.prompt_feedback}")
@@ -465,57 +375,47 @@ def chat_api():
             except Exception as feedback_err:
                 print(f"  Impossible de récupérer les détails du blocage: {feedback_err}")
                 response_text_raw = "Désolé, ma réponse a été bloquée car elle pourrait enfreindre les règles de sécurité."
-        except Exception as resp_err: # Gère d'autres erreurs potentielles
+        except Exception as resp_err:
              print(f"  ERREUR inattendue lors de l'accès à response.text : {resp_err}")
-             print(f"  Réponse brute complète : {response}") # Log la réponse brute pour le debug
+             print(f"  Réponse brute complète : {response}")
              response_text_raw = "Désolé, une erreur interne s'est produite lors de la réception de la réponse."
 
-        # Convertit la réponse (même les messages d'erreur) en HTML
         print(f"  Réponse reçue (début): '{response_text_raw[:100]}...'")
         response_html = markdown.markdown(response_text_raw, extensions=['fenced_code', 'tables', 'nl2br'])
         print("  Réponse convertie en HTML.")
 
-        # --- Stocker la réponse de l'assistant et retourner au client ---
-        assistant_history_entry = {
-            'role': 'assistant',
-            'text': response_html,
-            'raw_text': response_text_raw
-        }
+        assistant_history_entry = {'role': 'assistant', 'text': response_html, 'raw_text': response_text_raw}
         session['chat_history'].append(assistant_history_entry)
         session.modified = True
 
         print("  Envoi de la réponse HTML au client.")
         return jsonify({'success': True, 'message': response_html})
 
-    # --- Gestion des Erreurs spécifiques (Timeout, Fichier invalide, etc.) ---
-    except (TimeoutError, ValueError, ConnectionError, FileNotFoundError, types.StopCandidateException) as e:
+    # Correction: Utiliser genai.StopCandidateException
+    except (TimeoutError, ValueError, ConnectionError, FileNotFoundError, genai.StopCandidateException) as e:
         error_message = f"Erreur lors du traitement de la requête: {e}"
         print(f"ERREUR (Traitement/Appel API): {error_message}")
-        if isinstance(e, types.StopCandidateException):
+        # Correction: Utiliser genai.StopCandidateException pour la vérification
+        if isinstance(e, genai.StopCandidateException):
             error_message = "La génération a été stoppée, probablement à cause du contenu."
             print(f"  StopCandidateException: {e}")
 
-        if session.get('chat_history'):
-            # Retire le dernier message utilisateur SEULEMENT s'il a été ajouté dans ce try
-            if session['chat_history'][-1]['role'] == 'user':
-                 session['chat_history'].pop()
-                 session.modified = True
-                 print("  Dernier message utilisateur retiré de l'historique après erreur.")
+        if session.get('chat_history') and session['chat_history'][-1]['role'] == 'user':
+            session['chat_history'].pop()
+            session.modified = True
+            print("  Dernier message utilisateur retiré de l'historique après erreur.")
         return jsonify({'success': False, 'error': error_message}), 500
 
-    # --- Gestion des Erreurs Génériques/Inattendues ---
     except Exception as e:
         error_message = f"Une erreur interne inattendue est survenue: {e}"
         print(f"ERREUR CRITIQUE INATTENDUE: {error_message}")
-        traceback.print_exc() # Correction: Utilise traceback pour afficher les détails
-        if session.get('chat_history'):
-             if session['chat_history'][-1]['role'] == 'user':
-                 session['chat_history'].pop()
-                 session.modified = True
-                 print("  Dernier message utilisateur retiré de l'historique après erreur inattendue.")
-        return jsonify({'success': False, 'error': "Une erreur interne inattendue est survenue."}), 500 # Message générique au client
-
-    # --- Nettoyage (Exécuté dans tous les cas : succès ou erreur) ---
+        traceback.print_exc() # Correction: Utilise traceback pour détails
+        if session.get('chat_history') and session['chat_history'][-1]['role'] == 'user':
+            session['chat_history'].pop()
+            session.modified = True
+            print("  Dernier message utilisateur retiré de l'historique après erreur inattendue.")
+        return jsonify({'success': False, 'error': "Une erreur interne inattendue est survenue."}), 500
+
     finally:
         if filepath_to_delete and os.path.exists(filepath_to_delete):
             try:
@@ -527,12 +427,10 @@ def chat_api():
 @app.route('/clear', methods=['POST'])
 def clear_chat():
     """Efface l'historique de chat dans la session."""
-    session.pop('chat_history', None) # Supprime la clé de la session
+    session.pop('chat_history', None)
     print("API: Historique de chat effacé via /clear.")
-
     is_ajax = request.headers.get('X-Requested-With') == 'XMLHttpRequest' or \
               'application/json' in request.headers.get('Accept', '')
-
     if is_ajax:
          return jsonify({'success': True, 'message': 'Historique effacé.'})
     else:
@@ -543,10 +441,6 @@ def clear_chat():
 
 if __name__ == '__main__':
     print("Démarrage du serveur Flask...")
-    # Utiliser un port différent si 5000/7860 est déjà pris (ex: 5001)
-    # Le port 7860 est souvent utilisé par Gradio/Streamlit, vérifiez la disponibilité
-    port = int(os.environ.get('PORT', 7860)) # Garde 7860 comme vu dans vos logs
-    # debug=False en production ! debug=True pour développement seulement.
-    # ATTENTION: Les logs indiquaient debug=off, mais app.run(debug=True) force le mode debug.
-    # Mettez debug=False si vous ne voulez pas le rechargement auto et les tracebacks dans le navigateur.
+    port = int(os.environ.get('PORT', 7860))
+    # Mettre debug=False pour la production
     app.run(debug=True, host='0.0.0.0', port=port)