Update app.py

app.py

@@ -1,209 +1,171 @@
 import os
 import json
 import mimetypes
-import time
-import re # Pour la détection d'URL YouTube
-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, SafetySetting etc.
-# L'exception StopCandidateException est directement sous genai
-# from google.generativeai.types import StopCandidateException # Ne fonctionne pas
-
+import google.generativeai as genai
 import requests
 from werkzeug.utils import secure_filename
-import markdown # Pour convertir la réponse Markdown en HTML
+import markdown # Pour convertir la réponse en HTML
 
 # --- Configuration Initiale ---
-
-load_dotenv() # Charge les variables depuis .env
+load_dotenv()
 
 app = Flask(__name__)
 
-# Clé secrète FORTEMENT recommandée pour la sécurité des sessions
-app.config['SECRET_KEY'] = os.getenv('FLASK_SECRET_KEY', 'une-cle-secrete-tres-difficile-a-deviner')
+# Clé secrète FORTEMENT recommandée pour les sessions
+app.config['SECRET_KEY'] = os.getenv('FLASK_SECRET_KEY', 'dev-secret-key-replace-in-prod')
 
 # Configuration pour les uploads
 UPLOAD_FOLDER = 'temp'
-
-# Extensions autorisées (incluant vidéo)
-ALLOWED_EXTENSIONS = {'txt', 'pdf', 'png', 'jpg', 'jpeg', 'mp4', 'mov', 'avi', 'mkv', 'webm'}
-VIDEO_EXTENSIONS = {'mp4', 'mov', 'avi', 'mkv', 'webm'} # Pour identifier les vidéos
+ALLOWED_EXTENSIONS = {'txt', 'pdf', 'png', 'jpg', 'jpeg'} # Extensions autorisées
 app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
+app.config['MAX_CONTENT_LENGTH'] = 25 * 1024 * 1024  # Limite de taille (ex: 25MB)
 
-# Augmenter la limite pour les vidéos (ex: 100MB) - Ajustez si nécessaire
-app.config['MAX_CONTENT_LENGTH'] = 100 * 1024 * 1024
-
-# Crée le dossier temporaire s'il n'existe pas
+# Créer le dossier temp s'il n'existe pas
 os.makedirs(UPLOAD_FOLDER, exist_ok=True)
 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'
-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é (structure correcte pour GenerateContentConfig)
-SAFETY_SETTINGS_CONFIG = [
-    types.SafetySetting(
-      category=types.HarmCategory.HARM_CATEGORY_HATE_SPEECH,
-      threshold=types.HarmBlockThreshold.BLOCK_LOW_AND_ABOVE,
-    ),
-    types.SafetySetting(
-      category=types.HarmCategory.HARM_CATEGORY_HARASSMENT,
-      threshold=types.HarmBlockThreshold.BLOCK_LOW_AND_ABOVE,
-    ),
-    types.SafetySetting(
-      category=types.HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT,
-      threshold=types.HarmBlockThreshold.BLOCK_LOW_AND_ABOVE,
-    ),
-    types.SafetySetting(
-      category=types.HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT,
-      threshold=types.HarmBlockThreshold.BLOCK_LOW_AND_ABOVE,
-    )
+MODEL_FLASH = 'gemini-2.0-flash' # Default model
+MODEL_PRO = 'gemini-2.5-pro-exp-03-25' # Advanced model
+SYSTEM_INSTRUCTION = "Tu es un assistant intelligent et amical nommé Mariam. Tu assistes les utilisateurs au mieux de tes capacités. Tu as été créé par Aenir."
+SAFETY_SETTINGS = [
+    {"category": "HARM_CATEGORY_HARASSMENT", "threshold": "BLOCK_NONE"},
+    {"category": "HARM_CATEGORY_HATE_SPEECH", "threshold": "BLOCK_NONE"},
+    {"category": "HARM_CATEGORY_SEXUALLY_EXPLICIT", "threshold": "BLOCK_NONE"},
+    {"category": "HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "BLOCK_NONE"},
 ]
-
-
 GEMINI_CONFIGURED = False
-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
-    gemini_client = genai.Client(api_key=gemini_api_key)
-
-    # Vérifie si les modèles requis sont disponibles en utilisant le client
-    print("Vérification des modèles Gemini disponibles...")
-    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:
-            if available.startswith(f'models/{req}'):
-                models_found[req] = True
-
-    if all(models_found.values()):
-         print(f"Configuration Gemini effectuée. Modèles requis ({', '.join(required_models_prefixes)}) trouvés.")
-         print(f"Instruction Système: {SYSTEM_INSTRUCTION}")
-         GEMINI_CONFIGURED = True
+        print("ERREUR: Clé API GOOGLE_API_KEY manquante dans le fichier .env")
     else:
-        missing = [req for req, found in models_found.items() if not found]
-        raise ValueError(f"Les modèles Gemini requis suivants (ou commençant par) sont manquants : {missing}")
-
+        genai.configure(api_key=gemini_api_key)
+        # Just configure, don't create model instance yet
+        # Check if we can list models as a basic configuration test
+        models_list = [m.name for m in genai.list_models()]
+        if f'models/{MODEL_FLASH}' in models_list and f'models/{MODEL_PRO}' in models_list:
+             print(f"Configuration Gemini effectuée. Modèles requis ({MODEL_FLASH}, {MODEL_PRO}) disponibles.")
+             print(f"System instruction: {SYSTEM_INSTRUCTION}")
+             GEMINI_CONFIGURED = True
+        else:
+            print(f"ERREUR: Les modèles requis ({MODEL_FLASH}, {MODEL_PRO}) ne sont pas tous disponibles via l'API.")
+            print(f"Modèles trouvés: {models_list}")
 
 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
-    GEMINI_CONFIGURED = False
 
 # --- Fonctions Utilitaires ---
 
-def get_file_extension(filename):
-    """Retourne l'extension du fichier en minuscules, ou None."""
-    return filename.rsplit('.', 1)[1].lower() if '.' in filename else None
-
 def allowed_file(filename):
-    """Vérifie si l'extension du fichier est dans la liste autorisée."""
-    return get_file_extension(filename) in ALLOWED_EXTENSIONS
-
-def is_video_file(filename):
-    """Vérifie si l'extension correspond à un type vidéo connu."""
-    return get_file_extension(filename) in VIDEO_EXTENSIONS
-
-def is_youtube_url(url):
-    """Vérifie si la chaîne ressemble à une URL YouTube valide."""
-    if not url: return False
-    youtube_regex = re.compile(
-        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."""
-    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
-    try:
-        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()
-        while video_file.state == types.FileState.PROCESSING:
-            elapsed_time = time.time() - start_time
-            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)
-            video_file = gemini_client.files.get(name=video_file.name)
-
-        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:
-            print(f"Traitement vidéo terminé avec succès: {video_file.uri}")
-            return video_file
-        else:
-            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}")
-        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
-
-# --- Fonctions de Recherche Web (inchangées - implémentez si nécessaire) ---
+    """Vérifie si l'extension du fichier est autorisée."""
+    return '.' in filename and \
+           filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
 
 def perform_web_search(query):
+    """Effectue une recherche web via l'API Serper."""
     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
-    print(f"Recherche Web (simulation) pour : {query}")
-    return None
+
+    search_url = "https://google.serper.dev/search"
+    headers = {
+        'X-API-KEY': serper_api_key,
+        'Content-Type': 'application/json'
+    }
+    payload = json.dumps({"q": query, "gl": "fr", "hl": "fr"}) # Ajout localisation FR
+
+    try:
+        print(f"Recherche Serper pour: '{query}'")
+        response = requests.post(search_url, headers=headers, data=payload, timeout=10)
+        response.raise_for_status() # Lève une exception pour les erreurs HTTP (4xx, 5xx)
+        data = response.json()
+        print("Résultats de recherche Serper obtenus.")
+        # print(json.dumps(data, indent=2)) # Décommenter pour voir les résultats bruts
+        return data
+    except requests.exceptions.Timeout:
+        print("Erreur lors de la recherche web : Timeout")
+        return None
+    except requests.exceptions.RequestException as e:
+        print(f"Erreur lors de la recherche web : {e}")
+        # Essayer de lire le corps de la réponse d'erreur si possible
+        try:
+            error_details = e.response.json()
+            print(f"Détails de l'erreur Serper: {error_details}")
+        except:
+            pass # Ignorer si le corps n'est pas JSON ou n'existe pas
+        return None
+    except json.JSONDecodeError as e:
+        print(f"Erreur lors du décodage de la réponse JSON de Serper : {e}")
+        print(f"Réponse reçue (texte brut) : {response.text}")
+        return None
 
 def format_search_results(data):
-    if not data: return "Aucun résultat de recherche web pertinent."
-    results = ["Résultats Web:"]
+    """Met en forme les résultats de recherche (format Markdown)."""
+    if not data:
+        return "Aucun résultat de recherche web trouvé pertinent."
+
+    results = []
+
+    # Réponse directe (Answer Box)
+    if data.get('answerBox'):
+        ab = data['answerBox']
+        title = ab.get('title', '')
+        snippet = ab.get('snippet') or ab.get('answer', '')
+        if snippet:
+            results.append(f"**Réponse rapide : {title}**\n{snippet}\n")
+
+    # Knowledge Graph
+    if data.get('knowledgeGraph'):
+        kg = data['knowledgeGraph']
+        title = kg.get('title', '')
+        type = kg.get('type', '')
+        description = kg.get('description', '')
+        if title and description:
+             results.append(f"**{title} ({type})**\n{description}\n")
+        if kg.get('attributes'):
+             for attr, value in kg['attributes'].items():
+                  results.append(f"- {attr}: {value}")
+
+
+    # Résultats organiques
     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é."
+        results.append("**Pages web pertinentes :**")
+        for i, item in enumerate(data['organic'][:3], 1): # Top 3
+            title = item.get('title', 'Sans titre')
+            link = item.get('link', '#')
+            snippet = item.get('snippet', 'Pas de description.')
+            results.append(f"{i}. **[{title}]({link})**\n   {snippet}\n")
+
+    # People Also Ask
+    if data.get('peopleAlsoAsk'):
+        results.append("**Questions liées :**")
+        for i, item in enumerate(data['peopleAlsoAsk'][:2], 1): # Top 2
+             results.append(f"- {item.get('question', '')}")
 
-# --- Préparation Historique (Corrigé pour utiliser types.Part) ---
+
+    if not results:
+        return "Aucun résultat structuré trouvé dans la recherche web."
+
+    return "\n".join(results)
 
 def prepare_gemini_history(chat_history):
-    """Convertit l'historique de session pour l'API Gemini (texte seulement)."""
+    """Convertit l'historique stocké en session au format attendu par Gemini API."""
     gemini_history = []
     for message in chat_history:
         role = 'user' if message['role'] == 'user' else 'model'
-        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)
-            gemini_history.append({'role': role, 'parts': [text_part_object]})
+        # Utiliser le 'raw_text' stocké pour Gemini
+        text_part = message.get('raw_text', '') # Fallback au cas où
+        parts = [text_part]
+        # NOTE: La gestion des fichiers des tours PRÉCÉDENTS n'est pas gérée ici.
+        # L'API generate_content se concentre généralement sur le fichier du tour ACTUEL.
+        # Si une référence de fichier passée était nécessaire, il faudrait la stocker
+        # et la ré-attacher ici (potentiellement plus complexe).
+        gemini_history.append({'role': role, 'parts': parts})
     return gemini_history
 
 # --- Routes Flask ---
@@ -211,236 +173,252 @@ def prepare_gemini_history(chat_history):
 @app.route('/')
 def root():
     """Sert la page HTML principale."""
-    try:
-        return render_template('index.html')
-    except Exception as e:
-        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
+    return render_template('index.html')
 
 @app.route('/api/history', methods=['GET'])
 def get_history():
-    """Fournit l'historique de chat (formaté pour affichage) en JSON."""
+    """Fournit l'historique de chat stocké en session au format JSON."""
     if 'chat_history' not in session:
         session['chat_history'] = []
+
+    # Préparer l'historique pour l'affichage (contient déjà 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 de l'historique ({len(display_history)} messages)")
     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)."""
-    if not GEMINI_CONFIGURED or not gemini_client:
+    """Gère les nouvelles requêtes de chat via AJAX."""
+    if not GEMINI_CONFIGURED:
         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
+        return jsonify({'success': False, 'error': "Le service IA n'est pas configuré correctement."}), 503 # Service Unavailable
 
+    # Récupération des données du formulaire
     prompt = request.form.get('prompt', '').strip()
-    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'
+    use_web_search_str = request.form.get('web_search', 'false') # 'true' ou 'false'
+    use_web_search = use_web_search_str.lower() == 'true'
     file = request.files.get('file')
+    use_advanced_str = request.form.get('advanced_reasoning', 'false') # Get the new flag
+    use_advanced = use_advanced_str.lower() == 'true'
 
-    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
+    # Validation simple
+    if not prompt and not file:
+        return jsonify({'success': False, 'error': 'Veuillez fournir un message ou un fichier.'}), 400
 
     print(f"\n--- Nouvelle requête /api/chat ---")
-    print(f"  Prompt: '{prompt[:50]}...'")
-    print(f"  Fichier: {file.filename if file else 'Non'}")
-    print(f"  URL YouTube: {youtube_url if youtube_url else 'Non'}")
-    print(f"  Web Search: {use_web_search}, Advanced: {use_advanced}")
+    print(f"Prompt reçu: '{prompt[:50]}...'")
+    print(f"Recherche Web activée: {use_web_search}")
+    print(f"Raisonnement avancé demandé: {use_advanced}")
+    print(f"Fichier reçu: {file.filename if file else 'Aucun'}")
 
+    # Initialiser l'historique de session si nécessaire
     if 'chat_history' not in session:
         session['chat_history'] = []
 
-    uploaded_media_part = None
-    uploaded_filename_for_display = None
-    filepath_to_delete = None
-    is_media_request = False
-    media_type = None
+    uploaded_gemini_file = None # L'objet fichier retourné par genai.upload_file
+    uploaded_filename = None    # Juste le nom du fichier pour référence/affichage
+    filepath_to_delete = None   # Chemin du fichier local à supprimer après traitement
 
-    try:
-        if file and file.filename != '':
-            is_media_request = True
-            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}")
-
-            filepath = os.path.join(app.config['UPLOAD_FOLDER'], uploaded_filename_for_display)
-            file.save(filepath)
-            filepath_to_delete = filepath
-            print(f"  Fichier '{uploaded_filename_for_display}' sauvegardé -> '{filepath}'")
-            mime_type = mimetypes.guess_type(filepath)[0] or 'application/octet-stream'
-
-            if is_video_file(uploaded_filename_for_display):
-                media_type = 'video'
-                print("  Traitement VIDÉO Uploadée (avec polling)...")
-                processed_media_file = upload_video_with_polling(filepath, mime_type)
-                uploaded_media_part = types.Part(file_data=processed_media_file)
-            else:
-                print("  Traitement FICHIER standard via client.files...")
-                processed_media_file = gemini_client.files.upload(path=filepath, mime_type=mime_type)
-                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 ({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}")
-
-        elif youtube_url:
-             if not is_youtube_url(youtube_url):
-                 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
-                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}'")
-
-        elif prompt:
-            media_type = 'text'
-            print("  Traitement PROMPT texte seul.")
+    # --- Gestion de l'upload de fichier ---
+    if file and file.filename != '':
+        if allowed_file(file.filename):
+            try:
+                filename = secure_filename(file.filename)
+                filepath = os.path.join(app.config['UPLOAD_FOLDER'], filename)
+                file.save(filepath)
+                filepath_to_delete = filepath # Marquer pour suppression
+                uploaded_filename = filename
+                print(f"Fichier '{filename}' sauvegardé temporairement dans '{filepath}'")
+
+                # Détecter le MimeType pour Gemini
+                mime_type = mimetypes.guess_type(filepath)[0]
+                if not mime_type:
+                    mime_type = 'application/octet-stream' # Fallback
+                    print(f"AVERTISSEMENT: Impossible de deviner le MimeType pour '{filename}', utilisation de '{mime_type}'.")
+
+                # Uploader vers Google AI (peut prendre du temps)
+                print(f"Upload du fichier vers Google AI (MimeType: {mime_type})...")
+                # Note: L'API upload_file est générique et ne dépend pas du modèle Flash/Pro
+                uploaded_gemini_file = genai.upload_file(path=filepath, mime_type=mime_type)
+                print(f"Fichier '{uploaded_gemini_file.name}' uploadé avec succès vers Google AI.")
+
+            except Exception as e:
+                print(f"ERREUR Critique lors du traitement/upload du fichier '{filename}': {e}")
+                # Supprimer le fichier local même en cas d'erreur d'upload Gemini
+                if filepath_to_delete and os.path.exists(filepath_to_delete):
+                    try:
+                        os.remove(filepath_to_delete)
+                        print(f"Fichier temporaire '{filepath_to_delete}' supprimé après erreur.")
+                    except OSError as del_e:
+                         print(f"Erreur lors de la suppression du fichier temporaire après erreur: {del_e}")
+                # Renvoyer une erreur claire au client
+                return jsonify({'success': False, 'error': f"Erreur lors du traitement du fichier: {e}"}), 500
         else:
-            raise ValueError("Aucune entrée valide fournie.")
-
-        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}"
+            print(f"ERREUR: Type de fichier non autorisé: {file.filename}")
+            return jsonify({'success': False, 'error': f"Type de fichier non autorisé. Extensions permises: {', '.join(ALLOWED_EXTENSIONS)}"}), 400
+
+    # --- Préparation du message utilisateur pour l'historique et Gemini ---
+    # Texte brut pour Gemini (et pour l'historique interne)
+    raw_user_text = prompt
+    # Texte pour l'affichage dans l'interface (peut inclure le nom de fichier)
+    display_user_text = f"[{uploaded_filename}] {prompt}" if uploaded_filename and prompt else (prompt or f"[{uploaded_filename}]")
+
+    # Ajout à l'historique de session
+    user_history_entry = {
+        'role': 'user',
+        'text': display_user_text, # Pour get_history et potentiellement debug
+        'raw_text': raw_user_text,   # Pour l'envoi à Gemini via prepare_gemini_history
+        # On ne stocke PAS l'objet 'uploaded_gemini_file' dans la session
+    }
+    session['chat_history'].append(user_history_entry)
+    session.modified = True # Indiquer que la session a été modifiée
+
+    # --- Préparation des 'parts' pour l'appel Gemini ACTUEL ---
+    current_gemini_parts = []
+    if uploaded_gemini_file:
+        current_gemini_parts.append(uploaded_gemini_file) # L'objet fichier uploadé
+
+    final_prompt_for_gemini = raw_user_text # Commencer avec le texte brut
+
+    # --- Recherche Web (si activée et si un prompt textuel existe) ---
+    if use_web_search and raw_user_text:
+        print("Activation de la recherche web...")
+        search_data = perform_web_search(raw_user_text)
+        if search_data:
+            formatted_results = format_search_results(search_data)
+            # Construire un prompt enrichi pour Gemini
+            final_prompt_for_gemini = f"""Voici la question originale de l'utilisateur:
+"{raw_user_text}"
+
+J'ai effectué une recherche web et voici les informations pertinentes trouvées:
+--- DEBUT RESULTATS WEB ---
+{formatted_results}
+--- FIN RESULTATS WEB ---
+
+En te basant sur ces informations ET sur ta connaissance générale, fournis une réponse complète et bien structurée à la question originale de l'utilisateur."""
+            print("Prompt enrichi avec les résultats de recherche web.")
+        else:
+            print("Aucun résultat de recherche web pertinent trouvé ou erreur, utilisation du prompt original.")
+            # final_prompt_for_gemini reste raw_user_text
 
-        user_history_entry = {'role': 'user', 'text': display_user_text, 'raw_text': prompt}
-        session['chat_history'].append(user_history_entry)
-        session.modified = True
+    # Ajouter le texte (potentiellement enrichi) aux parts pour Gemini
+    current_gemini_parts.append(final_prompt_for_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.\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:
-             current_gemini_parts.append(types.Part(text=final_prompt_for_gemini)) # Correction: Toujours Part
-
-        if not current_gemini_parts:
-             raise ValueError("Impossible de traiter la requête : contenu vide.")
-
-        gemini_history = prepare_gemini_history(session['chat_history'][:-1])
-        # Structure correcte pour contents (liste de dictionnaires role/parts)
+    # --- Appel à l'API Gemini ---
+    try:
+        # Préparer l'historique des messages PRÉCÉDENTS
+        gemini_history = prepare_gemini_history(session['chat_history'][:-1]) # Exclut le message actuel
+        print(f"Préparation de l'appel Gemini avec {len(gemini_history)} messages d'historique.")
+        # Construire le contenu complet pour l'appel
         contents_for_gemini = gemini_history + [{'role': 'user', 'parts': current_gemini_parts}]
 
-        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
+        # Choisir le nom du modèle à utiliser
+        selected_model_name = MODEL_PRO if use_advanced else MODEL_FLASH
+        print(f"Utilisation du modèle Gemini: {selected_model_name}")
 
-        # 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,
-            safety_settings=SAFETY_SETTINGS_CONFIG,
-            system_instruction=types.Content(parts=[types.Part(text=SYSTEM_INSTRUCTION)], role="system")
+        # Créer l'instance du modèle spécifique pour cette requête
+        # Réutiliser les paramètres globaux (safety, system instruction)
+        active_model = genai.GenerativeModel(
+            model_name=selected_model_name,
+            safety_settings=SAFETY_SETTINGS, # defined globally
+            system_instruction=SYSTEM_INSTRUCTION # defined globally
         )
 
-        response_text_raw = ""
-        response_html = ""
+        # Appel API
+        print(f"Envoi de la requête à {selected_model_name}...")
+        # Utilisation de generate_content en mode non-streamé
+        response = active_model.generate_content(contents_for_gemini)
+        # print(response) # Décommenter pour voir la réponse brute de l'API
+
+        # Extraire le texte de la réponse (gestion d'erreur potentielle ici si la réponse est bloquée etc.)
+        # Gérer le cas où la réponse est bloquée par les safety settings
         try:
              response_text_raw = response.text
-        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}")
-                block_reason = response.prompt_feedback.block_reason_message or "Raison non spécifiée"
-                response_text_raw = f"Désolé, ma réponse a été bloquée car elle pourrait enfreindre les règles de sécurité ({block_reason})."
-            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:
-             print(f"  ERREUR inattendue lors de l'accès à response.text : {resp_err}")
-             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."
-
-        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.")
-
-        assistant_history_entry = {'role': 'assistant', 'text': response_html, 'raw_text': response_text_raw}
+        except ValueError:
+            # Si response.text échoue, la réponse a probablement été bloquée.
+            print("ERREUR: La réponse de Gemini a été bloquée (probablement par les safety settings).")
+            print(f"Détails du blocage : {response.prompt_feedback}")
+            # Vous pouvez décider quoi renvoyer au client ici.
+            # Soit une erreur spécifique, soit un message générique.
+            response_text_raw = "Désolé, ma réponse a été bloquée car elle pourrait enfreindre les règles de sécurité."
+            # Convertir ce message d'erreur en HTML aussi pour la cohérence
+            response_html = markdown.markdown(response_text_raw)
+
+        else:
+            # Si response.text réussit, continuer normalement
+            print(f"Réponse reçue de Gemini (brute, début): '{response_text_raw[:100]}...'")
+            # Convertir la réponse Markdown en HTML pour l'affichage
+            response_html = markdown.markdown(response_text_raw, extensions=['fenced_code', 'tables', 'nl2br'])
+            print("Réponse convertie en HTML.")
+
+
+        # Ajouter la réponse de l'assistant à l'historique de session
+        assistant_history_entry = {
+            'role': 'assistant',
+            'text': response_html,      # HTML pour l'affichage via get_history
+            'raw_text': response_text_raw # Texte brut pour les futurs appels Gemini
+        }
         session['chat_history'].append(assistant_history_entry)
         session.modified = True
 
-        print("  Envoi de la réponse HTML au client.")
+        # Renvoyer la réponse HTML au frontend
+        print("Envoi de la réponse HTML au client.")
         return jsonify({'success': True, 'message': response_html})
 
-    # 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}")
-        # 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') 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
-
     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 détails
-        if session.get('chat_history') and session['chat_history'][-1]['role'] == 'user':
+        print(f"ERREUR Critique lors de l'appel à Gemini ou du traitement de la réponse : {e}")
+        # En cas d'erreur, retirer le dernier message utilisateur de l'historique
+        # pour éviter les boucles d'erreur si le message lui-même pose problème.
+        # Vérifier si l'historique n'est pas vide avant de pop
+        if session.get('chat_history'):
             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
+            print("Le dernier message utilisateur a été retiré de l'historique suite à l'erreur.")
+        else:
+            print("L'historique était déjà vide lors de l'erreur.")
+
+        # Renvoyer une erreur générique mais informative
+        return jsonify({'success': False, 'error': f"Une erreur interne est survenue lors de la génération de la réponse. Détails: {e}"}), 500
 
     finally:
+        # --- Nettoyage du fichier temporaire ---
         if filepath_to_delete and os.path.exists(filepath_to_delete):
             try:
                 os.remove(filepath_to_delete)
-                print(f"  Fichier temporaire '{filepath_to_delete}' supprimé avec succès.")
+                print(f"Fichier temporaire '{filepath_to_delete}' supprimé avec succès.")
             except OSError as e:
-                print(f"  ERREUR lors de la suppression du fichier temporaire '{filepath_to_delete}': {e}")
+                print(f"ERREUR lors de la suppression du fichier temporaire '{filepath_to_delete}': {e}")
+
 
 @app.route('/clear', methods=['POST'])
 def clear_chat():
     """Efface l'historique de chat dans la session."""
     session.pop('chat_history', None)
+    # session.pop('web_search', None) # On ne stocke pas ça en session
     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', '')
+
+    # Adapter la réponse selon si c'est une requête AJAX (fetch) ou une soumission classique
+    # Vérification si la requête vient probablement de fetch (simple)
+    is_ajax = 'XMLHttpRequest' == request.headers.get('X-Requested-With') or \
+              'application/json' in request.headers.get('Accept', '') # Plus robuste
+
     if is_ajax:
          return jsonify({'success': True, 'message': 'Historique effacé.'})
     else:
+        # Comportement pour une soumission de formulaire classique (si jamais utilisé)
         flash("Conversation effacée.", "info")
-        return redirect(url_for('root'))
+        return redirect(url_for('root')) # Redirige vers la racine
 
-# --- Démarrage de l'application Flask ---
 
+# --- Démarrage de l'application ---
 if __name__ == '__main__':
     print("Démarrage du serveur Flask...")
-    port = int(os.environ.get('PORT', 7860))
-    # Mettre debug=False pour la production
+    # Utiliser host='0.0.0.0' pour rendre accessible sur le réseau local
+    # debug=True est pratique pour le développement, mais à désactiver en production !
+    # Changer le port si nécessaire (ex: 5000, 5001, 8080)
+    # Utiliser un port différent si le port 5000 est déjà pris
+    port = int(os.environ.get('PORT', 5001))
     app.run(debug=True, host='0.0.0.0', port=port)