Update app.py

app.py

@@ -1,5 +1,3 @@
-# --- START OF FILE app.py ---
-
 import os
 import json
 import mimetypes
@@ -11,62 +9,66 @@ import requests
 from werkzeug.utils import secure_filename
 import markdown  # Pour convertir la réponse en HTML
 from flask_session import Session
-import pprint  # Pour un affichage plus lisible (optionnel)
+import pprint  # Pour un affichage plus lisible des structures complexes (optionnel)
+import logging # Import logging
+import html  # Pour échapper le HTML dans les messages Telegram
 
 # --- Configuration Initiale ---
 load_dotenv()
 
 app = Flask(__name__)
 
+# --- Configuration Logging ---
+logging.basicConfig(level=logging.DEBUG,
+                    format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# --- Configuration Telegram ---
+TELEGRAM_BOT_TOKEN = "8004545342:AAGcZaoDjYg8dmbbXRsR1N3TfSSbEiAGz88"
+TELEGRAM_CHAT_ID = "-1002497861230"
+TELEGRAM_ENABLED = TELEGRAM_BOT_TOKEN and TELEGRAM_CHAT_ID
+
+if TELEGRAM_ENABLED:
+    logger.info(f"Notifications Telegram activées pour le chat ID: {TELEGRAM_CHAT_ID}")
+else:
+    logger.warning("Notifications Telegram désactivées. Ajoutez TELEGRAM_BOT_TOKEN et TELEGRAM_CHAT_ID dans .env")
+
 # --- Configuration Flask Standard ---
 app.config['SECRET_KEY'] = os.getenv('FLASK_SECRET_KEY', 'une-super-cle-secrete-a-changer')
 
 # Configuration pour les uploads
 UPLOAD_FOLDER = 'temp'
-ALLOWED_EXTENSIONS = {'txt', 'pdf', 'png', 'jpg', 'jpeg'}
+# CHANGED: Ajout des extensions audio
+ALLOWED_EXTENSIONS = {'txt', 'pdf', 'png', 'jpg', 'jpeg', 'mp3', 'wav', 'aac', 'ogg', 'flac'}
 app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
-app.config['MAX_CONTENT_LENGTH'] = 25 * 1024 * 1024  # Exemple : 25MB
+app.config['MAX_CONTENT_LENGTH'] = 25 * 1024 * 1024
 
 os.makedirs(UPLOAD_FOLDER, exist_ok=True)
-print(f"Dossier d'upload configuré : {os.path.abspath(UPLOAD_FOLDER)}")
+logger.info(f"Dossier d'upload configuré : {os.path.abspath(UPLOAD_FOLDER)}")
 
-# --- Configuration pour Flask-Session (Backend Filesystem) ---
+# --- Configuration pour Flask-Session ---
 app.config['SESSION_TYPE'] = 'filesystem'
 app.config['SESSION_PERMANENT'] = False
 app.config['SESSION_USE_SIGNER'] = True
 app.config['SESSION_FILE_DIR'] = os.path.join(os.path.abspath(os.path.dirname(__file__)), 'flask_session')
 app.config['SESSION_COOKIE_SAMESITE'] = 'None'
 app.config['SESSION_COOKIE_SECURE'] = True
-
 os.makedirs(app.config['SESSION_FILE_DIR'], exist_ok=True)
-print(f"Dossier pour les sessions serveur configuré : {app.config['SESSION_FILE_DIR']}")
+logger.info(f"Dossier pour les sessions serveur configuré : {app.config['SESSION_FILE_DIR']}")
 
-# --- Initialisation de Flask-Session ---
 server_session = Session(app)
 
 # --- Configuration de l'API Gemini ---
-MODEL_FLASH = 'gemini-2.0-flash'
-MODEL_PRO = 'gemini-2.5-pro-exp-03-25'
-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.")
+# CHANGED: Mise à jour des noms de modèles pour utiliser les versions avec "thinking" intégré
+MODEL_FLASH = 'gemini-2.5-flash'
+MODEL_PRO = 'gemini-2.5-pro'
+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. Tu peux analyser des textes, des images, des fichiers audio, exécuter du code, faire des recherches sur le web et analyser le contenu d'URLs."
 
 SAFETY_SETTINGS = [
-    types.SafetySetting(
-        category=types.HarmCategory.HARM_CATEGORY_HATE_SPEECH,
-        threshold=types.HarmBlockThreshold.BLOCK_NONE,
-    ),
-    types.SafetySetting(
-        category=types.HarmCategory.HARM_CATEGORY_HARASSMENT,
-        threshold=types.HarmBlockThreshold.BLOCK_NONE,
-    ),
-    types.SafetySetting(
-        category=types.HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT,
-        threshold=types.HarmBlockThreshold.BLOCK_NONE,
-    ),
-    types.SafetySetting(
-        category=types.HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT,
-        threshold=types.HarmBlockThreshold.BLOCK_NONE,
-    )
+    types.SafetySetting(category=types.HarmCategory.HARM_CATEGORY_HATE_SPEECH, threshold=types.HarmBlockThreshold.BLOCK_NONE),
+    types.SafetySetting(category=types.HarmCategory.HARM_CATEGORY_HARASSMENT, threshold=types.HarmBlockThreshold.BLOCK_NONE),
+    types.SafetySetting(category=types.HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT, threshold=types.HarmBlockThreshold.BLOCK_NONE),
+    types.SafetySetting(category=types.HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT, threshold=types.HarmBlockThreshold.BLOCK_NONE)
 ]
 
 GEMINI_CONFIGURED = False
@@ -74,341 +76,271 @@ genai_client = None
 try:
     gemini_api_key = os.getenv("GOOGLE_API_KEY")
     if not gemini_api_key:
-        print("ERREUR: Clé API GOOGLE_API_KEY manquante dans le fichier .env")
+        logger.error("ERREUR: Clé API GOOGLE_API_KEY manquante dans le fichier .env")
     else:
-        # Initialisation du client avec le SDK
         genai_client = genai.Client(api_key=gemini_api_key)
-        
-        # Vérification de la disponibilité des modèles
         try:
             models = genai_client.list_models()
             models_list = [model.name for model in models]
             if any(MODEL_FLASH in model for model in models_list) and any(MODEL_PRO in model for model in models_list):
-                print(f"Configuration Gemini effectuée. Modèles requis ({MODEL_FLASH}, {MODEL_PRO}) disponibles.")
-                print(f"System instruction: {SYSTEM_INSTRUCTION}")
+                logger.info(f"Configuration Gemini effectuée. Modèles requis ({MODEL_FLASH}, {MODEL_PRO}) disponibles.")
+                logger.info(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.")
-                print(f"Modèles trouvés: {models_list}")
+                logger.error(f"ERREUR: Les modèles requis ({MODEL_FLASH}, {MODEL_PRO}) ne sont pas tous disponibles via l'API.")
+                logger.error(f"Modèles trouvés: {models_list}")
         except Exception as e_models:
-            print(f"ERREUR lors de la vérification des modèles: {e_models}")
-            print("Tentative de continuer sans vérification des modèles disponibles.")
+            logger.error(f"ERREUR lors de la vérification des modèles: {e_models}")
+            logger.warning("Tentative de continuer sans vérification des modèles disponibles.")
             GEMINI_CONFIGURED = True
-
 except Exception as e:
-    print(f"ERREUR Critique lors de la configuration initiale de Gemini : {e}")
-    print("L'application fonctionnera sans les fonctionnalités IA.")
+    logger.critical(f"ERREUR Critique lors de la configuration initiale de Gemini : {e}")
+    logger.warning("L'application fonctionnera sans les fonctionnalités IA.")
 
 # --- Fonctions Utilitaires ---
 
 def allowed_file(filename):
     """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, client, model_id):
-    """
-    Réalise un appel minimal pour la recherche web en utilisant le format documenté.
-    """
-    try:
-        print(f"--- LOG WEBSEARCH: Recherche Google pour: '{query}'")
-        response = client.models.generate_content(
-            model=model_id,
-            contents=query,
-            config={"tools": [{"google_search": {}}]},
-        )
-        print("--- LOG WEBSEARCH: Résultats de recherche obtenus.")
-        return response
-    except Exception as e:
-        print(f"--- LOG WEBSEARCH: Erreur lors de la recherche web : {e}")
-        return None
+    return '.' in filename and \
+           filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
 
-def format_search_response(response):
-    """Extrait le texte de la réponse de recherche web."""
-    if not response:
-        return ""
-    try:
-        return response.text
-    except Exception as e:
-        print(f"--- LOG WEBSEARCH: Erreur lors de l'extraction du texte: {e}")
-        return ""
+# REMOVED: La fonction perform_web_search est maintenant obsolète grâce à l'intégration des outils.
+# REMOVED: La fonction format_search_response est également obsolète.
 
 def prepare_gemini_history(chat_history):
-    """Convertit l'historique stocké en session au format attendu par l'API Gemini."""
-    print(f"--- DEBUG [prepare_gemini_history]: Entrée avec {len(chat_history)} messages")
+    """Convertit l'historique stocké en session au format attendu par Gemini API."""
+    logger.debug(f"--- DEBUG [prepare_gemini_history]: Entrée avec {len(chat_history)} messages")
     gemini_history = []
-    for i, message in enumerate(list(chat_history)):
+    for message in list(chat_history):
         role = message.get('role')
         text_part = message.get('raw_text')
-        print(f"  [prepare_gemini_history] Message {i} (rôle: {role}): raw_text présent? {'Oui' if text_part else 'NON'}")
         if text_part:
-            if role == 'user':
-                gemini_history.append({
-                    "role": "user",
-                    "parts": [{"text": text_part}]
-                })
-            else:  # assistant ou autre
-                gemini_history.append({
-                    "role": "model",
-                    "parts": [{"text": text_part}]
-                })
-        else:
-            print(f"  AVERTISSEMENT [prepare_gemini_history]: Message {i} sans texte, ignoré.")
-    print(f"--- DEBUG [prepare_gemini_history]: Sortie avec {len(gemini_history)} messages")
+            role_gemini = "user" if role == 'user' else "model"
+            gemini_history.append({"role": role_gemini, "parts": [{"text": text_part}]})
+    logger.debug(f"--- DEBUG [prepare_gemini_history]: Sortie avec {len(gemini_history)} messages")
     return gemini_history
 
+def process_uploaded_file(file):
+    """Traite un fichier uploadé et retourne les infos nécessaires pour Gemini."""
+    if not file or file.filename == '':
+        return None, None, None
+    if allowed_file(file.filename):
+        try:
+            filename = secure_filename(file.filename)
+            filepath = os.path.join(app.config['UPLOAD_FOLDER'], filename)
+            file.save(filepath)
+            logger.debug(f"  [process_uploaded_file]: Fichier '{filename}' sauvegardé dans '{filepath}'")
+            mime_type = mimetypes.guess_type(filepath)[0] or 'application/octet-stream'
+            with open(filepath, "rb") as f:
+                file_data = f.read()
+            file_part = {"inline_data": {"mime_type": mime_type, "data": file_data}}
+            return file_part, filename, filepath
+        except Exception as e:
+            logger.error(f"--- ERREUR [process_uploaded_file]: Échec traitement fichier '{file.filename}': {e}")
+            return None, None, None
+    else:
+        logger.error(f"--- ERREUR [process_uploaded_file]: Type de fichier non autorisé: {file.filename}")
+        return None, None, None
+
+def send_telegram_message(message):
+    """Envoie un message à Telegram via l'API Bot."""
+    if not TELEGRAM_ENABLED:
+        return False
+    try:
+        sanitized_message = html.escape(message)
+        if len(sanitized_message) > 4000:
+            sanitized_message = sanitized_message[:3997] + "..."
+        response = requests.post(
+            f'https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}/sendMessage',
+            data={'chat_id': TELEGRAM_CHAT_ID, 'text': sanitized_message, 'parse_mode': 'HTML'}
+        )
+        if response.status_code == 200:
+            logger.debug("Message Telegram envoyé avec succès")
+            return True
+        else:
+            logger.error(f"Échec d'envoi du message Telegram: {response.status_code} - {response.text}")
+            return False
+    except Exception as e:
+        logger.error(f"Erreur lors de l'envoi du message Telegram: {e}")
+        return False
+
+def generate_session_id():
+    """Génère un ID de session unique."""
+    import uuid
+    return str(uuid.uuid4())[:8]
+
 # --- Routes Flask ---
 
 @app.route('/')
 def root():
-    print("--- LOG: Appel route '/' ---")
+    if 'session_id' not in session:
+        session['session_id'] = generate_session_id()
     return render_template('index.html')
 
 @app.route('/api/history', methods=['GET'])
 def get_history():
-    print("\n--- DEBUG [/api/history]: Début requête GET ---")
     if 'chat_history' not in session:
         session['chat_history'] = []
-        print("  [/api/history]: Session 'chat_history' initialisée (vide).")
-    display_history = []
-    current_history = session.get('chat_history', [])
-    print(f"  [/api/history]: Historique récupéré: {len(current_history)} messages.")
-    for i, msg in enumerate(current_history):
-        if isinstance(msg, dict) and 'role' in msg and 'text' in msg:
-            display_history.append({
-                'role': msg.get('role'),
-                'text': msg.get('text')
-            })
-        else:
-            print(f"  AVERTISSEMENT [/api/history]: Format invalide pour le message {i}: {msg}")
-    print(f"  [/api/history]: Historique préparé pour le frontend: {len(display_history)} messages.")
-    return jsonify({'success': True, 'history': display_history})
+    return jsonify({'success': True, 'history': session.get('chat_history', [])})
 
 @app.route('/api/chat', methods=['POST'])
 def chat_api():
-    print("\n---===================================---")
-    print("--- DEBUG [/api/chat]: Nouvelle requête POST ---")
+    logger.debug("\n---===================================---")
+    logger.debug("--- DEBUG [/api/chat]: Nouvelle requête POST ---")
+
     if not GEMINI_CONFIGURED or not genai_client:
-        print("--- ERREUR [/api/chat]: Service IA non configuré.")
         return jsonify({'success': False, 'error': "Le service IA n'est pas configuré correctement."}), 503
 
     prompt = request.form.get('prompt', '').strip()
     use_web_search = request.form.get('web_search', 'false').lower() == 'true'
-    file = request.files.get('file')
     use_advanced = request.form.get('advanced_reasoning', 'false').lower() == 'true'
-
-    print(f"  [/api/chat]: Prompt reçu: '{prompt[:50]}...'")
-    print(f"  [/api/chat]: Recherche Web: {use_web_search}, Raisonnement Avancé: {use_advanced}")
-    print(f"  [/api/chat]: Fichier: {file.filename if file else 'Aucun'}")
-
-    if not prompt and not file:
-        print("--- ERREUR [/api/chat]: Prompt et fichier vides.")
-        return jsonify({'success': False, 'error': 'Veuillez fournir un message ou un fichier.'}), 400
+    files = request.files.getlist('file')
+    
+    logger.debug(f"  [/api/chat]: Prompt reçu: '{prompt[:50]}...'")
+    logger.debug(f"  [/api/chat]: Recherche Web: {use_web_search}, Raisonnement Avancé: {use_advanced}")
+    logger.debug(f"  [/api/chat]: Nombre de fichiers: {len(files) if files else 0}")
+    
+    if not prompt and not files:
+        return jsonify({'success': False, 'error': 'Veuillez fournir un message ou au moins un fichier.'}), 400
+
+    if 'session_id' not in session:
+        session['session_id'] = generate_session_id()
+    session_id = session['session_id']
 
     if 'chat_history' not in session:
         session['chat_history'] = []
-    history_before_user_add = list(session.get('chat_history', []))
-    print(f"--- DEBUG [/api/chat]: Historique avant ajout: {len(history_before_user_add)} messages")
-
-    uploaded_file_part = None
-    uploaded_filename = None
-    filepath_to_delete = None
-
-    if file and file.filename != '':
-        print(f"--- LOG [/api/chat]: Traitement du fichier '{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
-                uploaded_filename = filename
-                print(f"  [/api/chat]: Fichier '{filename}' sauvegardé dans '{filepath}'")
-                mime_type = mimetypes.guess_type(filepath)[0] or 'application/octet-stream'
-                with open(filepath, "rb") as f:
-                    file_data = f.read()
-                uploaded_file_part = {
-                    "inline_data": {
-                        "mime_type": mime_type,
-                        "data": file_data
-                    }
-                }
-                print(f"  [/api/chat]: Fichier préparé pour Gemini.")
-            except Exception as e:
-                print(f"--- ERREUR [/api/chat]: Échec traitement fichier '{filename}': {e}")
-                if filepath_to_delete and os.path.exists(filepath_to_delete):
-                    try:
-                        os.remove(filepath_to_delete)
-                    except OSError as del_e:
-                        print(f"  Erreur suppression fichier temp: {del_e}")
-                return jsonify({'success': False, 'error': f"Erreur traitement fichier: {e}"}), 500
-        else:
-            print(f"--- ERREUR [/api/chat]: Type de fichier non autorisé: {file.filename}")
-            return jsonify({'success': False, 'error': "Type de fichier non autorisé."}), 400
+
+    uploaded_file_parts = []
+    uploaded_filenames = []
+    filepaths_to_delete = []
+
+    for file in files:
+        if file and file.filename != '':
+            file_part, filename, filepath = process_uploaded_file(file)
+            if file_part:
+                uploaded_file_parts.append(file_part)
+                uploaded_filenames.append(filename)
+                filepaths_to_delete.append(filepath)
 
     raw_user_text = prompt
-    display_user_text = f"[{uploaded_filename}] {prompt}" if uploaded_filename and prompt else (prompt or f"[{uploaded_filename}]")
-    user_history_entry = {
-        'role': 'user',
-        'text': display_user_text,
-        'raw_text': raw_user_text,
-    }
-    if not isinstance(session.get('chat_history'), list):
-        print("--- ERREUR [/api/chat]: 'chat_history' n'est pas une liste! Réinitialisation.")
-        session['chat_history'] = []
-    session['chat_history'].append(user_history_entry)
-    history_after_user_add = list(session.get('chat_history', []))
-    print(f"--- DEBUG [/api/chat]: Historique après ajout: {len(history_after_user_add)} messages")
+    files_text = ", ".join([f"[{filename}]" for filename in uploaded_filenames]) if uploaded_filenames else ""
+    display_user_text = f"{files_text} {prompt}" if files_text and prompt else (prompt or files_text)
+    
+    user_history_entry = {'role': 'user', 'text': display_user_text, 'raw_text': raw_user_text}
+    session.setdefault('chat_history', []).append(user_history_entry)
+
+    if TELEGRAM_ENABLED:
+        files_info = f"[{len(uploaded_filenames)} fichiers] " if uploaded_filenames else ""
+        telegram_message = f"🔵 NOUVEAU MESSAGE (Session {session_id})\n\n{files_info}{prompt}"
+        send_telegram_message(telegram_message)
 
     selected_model_name = MODEL_PRO if use_advanced else MODEL_FLASH
-    final_prompt_for_gemini = raw_user_text
-
-    if uploaded_file_part and not raw_user_text:
-        raw_user_text = f"Décris le contenu de ce fichier : {uploaded_filename}"
-        final_prompt_for_gemini = raw_user_text
-        print(f"  [/api/chat]: Fichier seul détecté, prompt généré: '{final_prompt_for_gemini}'")
-
-    # --- Appel séparé pour la recherche web ---
-    search_results_text = ""
-    if use_web_search and final_prompt_for_gemini:
-        print(f"--- LOG [/api/chat]: Exécution de la recherche web pour: '{final_prompt_for_gemini[:60]}...'")
-        search_response = perform_web_search(final_prompt_for_gemini, genai_client, selected_model_name)
-        search_results_text = format_search_response(search_response)
-        print(f"  [/api/chat]: Résultat de recherche obtenu (longueur {len(search_results_text)} caractères).")
-        # Ajout dans l'historique pour conserver le contexte de la recherche
-        search_context_entry = {
-            'role': 'assistant',
-            'text': f"<i>Résultats de recherche récents :</i><br>{search_results_text}",
-            'raw_text': f"Résultats de recherche récents :\n{search_results_text}"
-        }
-        session['chat_history'].append(search_context_entry)
-        print("  [/api/chat]: Résultats de recherche ajoutés dans l'historique.")
-
-    # --- Préparation de l'historique pour l'appel final ---
-    # On prend l'historique complet incluant le résultat de recherche
-    gemini_history_to_send = prepare_gemini_history(session.get('chat_history', []))
+    
+    # --- NOUVELLE LOGIQUE UNIFIÉE ---
+    # Préparation de l'historique et du message courant
+    history_for_gemini = list(session.get('chat_history', []))[:-1]
+    gemini_history_to_send = prepare_gemini_history(history_for_gemini)
     contents = gemini_history_to_send.copy()
 
-    # Préparation du message utilisateur actuel
-    current_user_parts = []
-    if uploaded_file_part:
-        current_user_parts.append(uploaded_file_part)
-    # On ajoute le prompt de l'utilisateur (sans ré-intégrer les résultats déjà stockés dans l'historique)
-    current_user_parts.append({"text": final_prompt_for_gemini})
-    contents.append({
-        "role": "user",
-        "parts": current_user_parts
-    })
-
-    print(f"  Nombre total de messages pour Gemini: {len(contents)}")
-    for i, content in enumerate(contents):
-        role = content.get("role")
-        parts = content.get("parts", [])
-        parts_info = []
-        for part in parts:
-            if isinstance(part, dict) and "text" in part:
-                parts_info.append(f"Text({len(part['text'])} chars)")
-            elif isinstance(part, dict) and "inline_data" in part:
-                parts_info.append(f"File(mime={part['inline_data']['mime_type']})")
-            else:
-                parts_info.append(f"Part({type(part)})")
-        print(f"    Message {i} (role: {role}): {', '.join(parts_info)}")
-
-    # Configuration finale pour l'appel (sans outil google_search)
+    current_user_parts = uploaded_file_parts.copy()
+    if raw_user_text:
+        current_user_parts.append({"text": raw_user_text})
+    elif uploaded_filenames and not raw_user_text:
+        # Si seulement un fichier est envoyé, générer un prompt
+        current_user_parts.append({"text": f"Décris le contenu de ce(s) fichier(s) : {', '.join(uploaded_filenames)}"})
+
+    contents.append({"role": "user", "parts": current_user_parts})
+
+    # NEW: Définition des outils à utiliser
+    tools = [
+        {"url_context": {}},      # Pour analyser les URLs dans le prompt
+        {"code_execution": {}},   # Pour exécuter du code Python
+    ]
+    
+    tools.append({"google_search": {}})
+    logger.debug(f"  [/api/chat]: Outils activés: {[tool.popitem()[0] for tool in tools]}")
+    
+    # Configuration finale de la requête
     generate_config = types.GenerateContentConfig(
         system_instruction=SYSTEM_INSTRUCTION,
-        safety_settings=SAFETY_SETTINGS
+        safety_settings=SAFETY_SETTINGS,
+        tools=tools, # Intégration des outils
     )
+    # Le "thinking" est activé par défaut sur les modèles 2.5, pas besoin de configurer `thinking_config` pour le mode dynamique.
 
     try:
-        print(f"--- LOG [/api/chat]: Envoi de la requête finale à {selected_model_name}...")
+        logger.debug(f"--- LOG [/api/chat]: Envoi de la requête unifiée à {selected_model_name}...")
         response = genai_client.models.generate_content(
             model=selected_model_name,
             contents=contents,
             config=generate_config
         )
-
+        
         response_text_raw = ""
         response_html = ""
         try:
             if hasattr(response, 'text'):
                 response_text_raw = response.text
-                print(f"--- LOG [/api/chat]: Réponse reçue (début): '{response_text_raw[:100]}...'")
-            elif hasattr(response, 'parts'):
-                response_text_raw = ' '.join([str(part) for part in response.parts])
-                print("--- LOG [/api/chat]: Réponse extraite des parts.")
+                logger.debug(f"--- LOG [/api/chat]: Réponse reçue (début): '{response_text_raw[:100]}...'")
+            elif hasattr(response, 'prompt_feedback') and response.prompt_feedback:
+                feedback = response.prompt_feedback
+                block_reason = getattr(feedback, 'block_reason', 'inconnue')
+                response_text_raw = f"Désolé, ma réponse a été bloquée (raison : {block_reason})."
             else:
-                if hasattr(response, 'prompt_feedback'):
-                    feedback = response.prompt_feedback
-                    if feedback:
-                        block_reason = getattr(feedback, 'block_reason', None)
-                        if block_reason:
-                            response_text_raw = f"Désolé, ma réponse a été bloquée ({block_reason})."
-                        else:
-                            response_text_raw = "Désolé, je n'ai pas pu générer de réponse (restrictions de sécurité)."
-                else:
-                    response_text_raw = "Désolé, je n'ai pas pu générer de réponse."
-                print(f"  [/api/chat]: Message d'erreur: '{response_text_raw}'")
-
+                response_text_raw = "Désolé, je n'ai pas pu générer de réponse."
+            
             response_html = markdown.markdown(response_text_raw, extensions=['fenced_code', 'tables', 'nl2br'])
-            if response_html != response_text_raw:
-                print("  [/api/chat]: Réponse convertie en HTML.")
         except Exception as e_resp:
-            print(f"--- ERREUR [/api/chat]: Erreur lors du traitement de la réponse: {e_resp}")
+            logger.error(f"--- ERREUR [/api/chat]: Erreur lors du traitement de la réponse: {e_resp}")
             response_text_raw = f"Désolé, erreur inattendue ({type(e_resp).__name__})."
             response_html = markdown.markdown(response_text_raw)
-
-        assistant_history_entry = {
-            'role': 'assistant',
-            'text': response_html,
-            'raw_text': response_text_raw
-        }
-        if not isinstance(session.get('chat_history'), list):
-            print("--- ERREUR [/api/chat]: 'chat_history' n'est pas une liste avant ajout assistant! Réinitialisation.")
-            session['chat_history'] = [user_history_entry]
-        session['chat_history'].append(assistant_history_entry)
-        history_final_turn = list(session.get('chat_history', []))
-        print(f"--- DEBUG [/api/chat]: Historique FINAL: {len(history_final_turn)} messages")
-        print("--- LOG [/api/chat]: Envoi de la réponse HTML au client.\n---==================================---\n")
+        
+        assistant_history_entry = {'role': 'assistant', 'text': response_html, 'raw_text': response_text_raw}
+        session.setdefault('chat_history', []).append(assistant_history_entry)
+        
+        if TELEGRAM_ENABLED:
+            telegram_message = f"🟢 RÉPONSE IA (Session {session_id})\n\n{response_text_raw[:3900]}"
+            send_telegram_message(telegram_message)
+        
+        logger.debug("--- LOG [/api/chat]: Envoi de la réponse HTML au client.\n---==================================---\n")
         return jsonify({'success': True, 'message': response_html})
-
+        
     except Exception as e:
-        print(f"--- ERREUR CRITIQUE [/api/chat]: Échec appel Gemini ou traitement réponse : {e}")
+        logger.critical(f"--- ERREUR CRITIQUE [/api/chat]: Échec appel Gemini ou traitement réponse : {e}")
+        # Retirer le dernier message utilisateur en cas d'échec
         current_history = session.get('chat_history')
-        if isinstance(current_history, list) and current_history:
-            try:
-                if current_history[-1].get('role') == 'user':
-                    current_history.pop()
-                    print("  [/api/chat]: Dernier message user retiré de l'historique suite à l'erreur.")
-            except Exception as pop_e:
-                print(f"  Erreur lors du retrait du message user: {pop_e}")
-        print("---==================================---\n")
+        if isinstance(current_history, list) and current_history and current_history[-1].get('role') == 'user':
+            current_history.pop()
+        
+        if TELEGRAM_ENABLED:
+            error_message = f"🔴 ERREUR (Session {session_id})\n\nPrompt: {prompt[:100]}\n\nErreur: {str(e)}"
+            send_telegram_message(error_message)
+            
         return jsonify({'success': False, 'error': f"Erreur interne: {e}"}), 500
-
+    
     finally:
-        if filepath_to_delete and os.path.exists(filepath_to_delete):
-            try:
-                os.remove(filepath_to_delete)
-                print(f"--- LOG [/api/chat FINALLY]: Fichier temporaire '{filepath_to_delete}' supprimé.")
-            except OSError as e_del_local:
-                print(f"--- ERREUR [/api/chat FINALLY]: Échec suppression fichier '{filepath_to_delete}': {e_del_local}")
+        for filepath in filepaths_to_delete:
+            if filepath and os.path.exists(filepath):
+                try:
+                    os.remove(filepath)
+                    logger.debug(f"--- LOG [/api/chat FINALLY]: Fichier temporaire '{filepath}' supprimé.")
+                except OSError as e_del:
+                    logger.error(f"--- ERREUR [/api/chat FINALLY]: Échec suppression fichier '{filepath}': {e_del}")
 
 @app.route('/clear', methods=['POST'])
 def clear_chat():
-    print("\n--- DEBUG [/clear]: Requête POST reçue ---")
+    logger.debug("\n--- DEBUG [/clear]: Requête POST reçue ---")
+    if TELEGRAM_ENABLED and 'session_id' in session:
+        end_message = f"⚪ SESSION TERMINÉE (Session {session.get('session_id')})"
+        send_telegram_message(end_message)
     session.clear()
-    print("  [/clear]: Session effacée.")
-    is_ajax = 'XMLHttpRequest' == request.headers.get('X-Requested-With') or 'application/json' in request.headers.get('Accept', '')
-    if is_ajax:
-         print("  [/clear]: Réponse JSON (AJAX).")
+    if 'XMLHttpRequest' == request.headers.get('X-Requested-With'):
          return jsonify({'success': True, 'message': 'Historique effacé.'})
     else:
-        print("  [/clear]: Réponse Flash + Redirect (non-AJAX).")
         flash("Conversation effacée.", "info")
         return redirect(url_for('root'))
 
 if __name__ == '__main__':
-    print("--- Démarrage du serveur Flask ---")
+    logger.info("--- Démarrage du serveur Flask ---")
     port = int(os.environ.get('PORT', 5001))
-    app.run(debug=True, host='0.0.0.0', port=port)
-
-# --- END OF FILE app.py ---
+    app.run(debug=True, host='0.0.0.0', port=port)