Update app.py

app.py

@@ -1,346 +1,313 @@
+from flask import Flask, render_template, request, jsonify, Response, session
 import os
 import json
-import mimetypes
-from flask import Flask, request, session, jsonify, redirect, url_for, flash, render_template
-from dotenv import load_dotenv
+import base64
 from google import genai
 from google.genai import types
-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 des structures complexes (optionnel)
-import logging # Import logging
-import html  # Pour échapper le HTML dans les messages Telegram
-
-# --- Configuration Initiale ---
-load_dotenv()
+import uuid
+from datetime import datetime
+import io
+from typing import Optional, List, Dict, Union
 
 app = Flask(__name__)
+app.secret_key = 'your-secret-key-here'  # Changez cette clé !
 
-# --- 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 de l'upload
+UPLOAD_FOLDER = 'uploads'
+ALLOWED_EXTENSIONS = {'png', 'jpg', 'jpeg', 'pdf', 'mp4', 'mov', 'txt', 'csv', 'json'}
+MAX_CONTENT_LENGTH = 16 * 1024 * 1024  # 16MB max file size
 
-# --- 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'
-# 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
+app.config['MAX_CONTENT_LENGTH'] = MAX_CONTENT_LENGTH
 
+# Créer le dossier uploads s'il n'existe pas
 os.makedirs(UPLOAD_FOLDER, exist_ok=True)
-logger.info(f"Dossier d'upload configuré : {os.path.abspath(UPLOAD_FOLDER)}")
-
-# --- 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)
-logger.info(f"Dossier pour les sessions serveur configuré : {app.config['SESSION_FILE_DIR']}")
-
-server_session = Session(app)
 
-# --- Configuration de l'API Gemini ---
-# 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."
+# Initialisation du client Gemini
+API_KEY = "AIzaSyAMYpF67aqFnWDJESWOx1dC-w3sEU29VcM"
+client = genai.Client(api_key=API_KEY)
 
-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)
-]
-
-GEMINI_CONFIGURED = False
-genai_client = None
-try:
-    gemini_api_key = os.getenv("GOOGLE_API_KEY")
-    if not gemini_api_key:
-        logger.error("ERREUR: Clé API GOOGLE_API_KEY manquante dans le fichier .env")
-    else:
-        genai_client = genai.Client(api_key=gemini_api_key)
-        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):
-                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:
-                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:
-            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:
-    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 ---
+# Configuration des modèles disponibles
+MODELS = {
+    "Gemini 2.5 Flash": "gemini-2.5-flash",
+    "Gemini 2.5 Pro": "gemini-2.5-pro",
+    "Gemini 2.5 Flash Lite": "gemini-2.5-flash-lite",
+    "Gemini 2.0 Flash": "gemini-2.0-flash"
+}
 
 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
-
-# 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 Gemini API."""
-    logger.debug(f"--- DEBUG [prepare_gemini_history]: Entrée avec {len(chat_history)} messages")
-    gemini_history = []
-    for message in list(chat_history):
-        role = message.get('role')
-        text_part = message.get('raw_text')
-        if text_part:
-            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():
-    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():
-    if 'chat_history' not in session:
-        session['chat_history'] = []
-    return jsonify({'success': True, 'history': session.get('chat_history', [])})
-
-@app.route('/api/chat', methods=['POST'])
-def chat_api():
-    logger.debug("\n---===================================---")
-    logger.debug("--- DEBUG [/api/chat]: Nouvelle requête POST ---")
-
-    if not GEMINI_CONFIGURED or not genai_client:
-        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'
-    use_advanced = request.form.get('advanced_reasoning', 'false').lower() == 'true'
-    files = request.files.getlist('file')
+    return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
+
+def configure_tools() -> List[types.Tool]:
+    """Configure tous les outils par défaut"""
+    tools = []
+    tools.append(types.Tool(code_execution=types.ToolCodeExecution()))
+    tools.append(types.Tool(google_search=types.GoogleSearch()))
+    tools.append(types.Tool(url_context=types.UrlContext()))
+    return tools
+
+def get_generation_config(
+    model: str,
+    thinking_enabled: bool = True,
+    include_thoughts: bool = False
+) -> types.GenerateContentConfig:
+    """Configuration optimisée par défaut"""
+    config_dict = {
+        "temperature": 0.7,
+        "max_output_tokens": 8192,
+        "top_p": 0.9,
+        "top_k": 40,
+        "tools": configure_tools()
+    }
     
-    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 thinking_enabled:
+        config_dict["thinking_config"] = types.ThinkingConfig(
+            thinking_budget=-1,  # Dynamique par défaut
+            include_thoughts=include_thoughts
+        )
     
-    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'] = []
-
-    uploaded_file_parts = []
-    uploaded_filenames = []
-    filepaths_to_delete = []
+    return types.GenerateContentConfig(**config_dict)
 
-    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
-    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)
+def process_uploaded_file(file) -> Optional[types.Part]:
+    """Traite les fichiers uploadés"""
+    if not file:
+        return None
     
-    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
+    file_bytes = file.read()
+    mime_type = file.content_type
     
-    # --- 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()
-
-    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
-    ]
+    # Réinitialiser le pointeur du fichier
+    file.seek(0)
     
-    tools.append({"google_search": {}})
-    logger.debug(f"  [/api/chat]: Outils activés: {[tool.popitem()[0] for tool in tools]}")
+    # Gestion des différents types de fichiers
+    if mime_type.startswith("image/"):
+        return types.Part.from_bytes(data=file_bytes, mime_type=mime_type)
+    elif mime_type == "application/pdf":
+        return types.Part.from_bytes(data=file_bytes, mime_type=mime_type)
+    elif mime_type.startswith("video/"):
+        return types.Part.from_bytes(data=file_bytes, mime_type=mime_type)
+    elif mime_type in ["text/plain", "text/csv", "application/json"]:
+        return types.Part.from_bytes(data=file_bytes, mime_type=mime_type)
     
-    # Configuration finale de la requête
-    generate_config = types.GenerateContentConfig(
-        system_instruction=SYSTEM_INSTRUCTION,
-        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.
+    return None
 
-    try:
-        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 = ""
+@app.route('/')
+def index():
+    """Page principale"""
+    return render_template('index.html', models=MODELS)
+
+@app.route('/send_message', methods=['POST'])
+def send_message():
+    """Endpoint pour envoyer un message avec streaming"""
+    def generate():
         try:
-            if hasattr(response, 'text'):
-                response_text_raw = response.text
-                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:
-                response_text_raw = "Désolé, je n'ai pas pu générer de réponse."
+            # Récupération des données
+            data = request.get_json()
+            message = data.get('message', '')
+            model = data.get('model', 'gemini-2.5-flash')
+            thinking_enabled = data.get('thinking_enabled', True)
+            include_thoughts = data.get('include_thoughts', False)
             
-            response_html = markdown.markdown(response_text_raw, extensions=['fenced_code', 'tables', 'nl2br'])
-        except Exception as 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}
-        session.setdefault('chat_history', []).append(assistant_history_entry)
+            if not message.strip():
+                yield f"data: {json.dumps({'error': 'Message vide'})}\n\n"
+                return
+            
+            # Configuration de génération
+            generation_config = get_generation_config(
+                model=model,
+                thinking_enabled=thinking_enabled,
+                include_thoughts=include_thoughts
+            )
+            
+            # Initialisation ou récupération du chat
+            chat_id = session.get('chat_id')
+            if not chat_id:
+                chat_id = str(uuid.uuid4())
+                session['chat_id'] = chat_id
+                session['chat'] = client.chats.create(
+                    model=model,
+                    config=generation_config
+                )
+            
+            chat = session.get('chat')
+            if not chat:
+                session['chat'] = client.chats.create(
+                    model=model,
+                    config=generation_config
+                )
+                chat = session['chat']
+            
+            # Préparation du contenu
+            contents = [message]
+            
+            # Envoi du message avec streaming
+            response_stream = chat.send_message_stream(
+                contents,
+                config=generation_config
+            )
+            
+            # Streaming de la réponse
+            full_response = ""
+            thoughts_content = ""
+            
+            for chunk in response_stream:
+                for part in chunk.candidates[0].content.parts:
+                    if part.text:
+                        if part.thought and include_thoughts:
+                            thoughts_content += part.text
+                            yield f"data: {json.dumps({'type': 'thought', 'content': part.text})}\n\n"
+                        else:
+                            full_response += part.text
+                            yield f"data: {json.dumps({'type': 'text', 'content': part.text})}\n\n"
+            
+            # Message de fin
+            yield f"data: {json.dumps({'type': 'end', 'full_response': full_response})}\n\n"
+            
+        except Exception as e:
+            yield f"data: {json.dumps({'error': str(e)})}\n\n"
+    
+    return Response(generate(), mimetype='text/event-stream')
+
+@app.route('/upload_file', methods=['POST'])
+def upload_file():
+    """Endpoint pour uploader des fichiers"""
+    try:
+        if 'file' not in request.files:
+            return jsonify({'error': 'Aucun fichier fourni'}), 400
         
-        if TELEGRAM_ENABLED:
-            telegram_message = f"🟢 RÉPONSE IA (Session {session_id})\n\n{response_text_raw[:3900]}"
-            send_telegram_message(telegram_message)
+        file = request.files['file']
+        if file.filename == '':
+            return jsonify({'error': 'Aucun fichier sélectionné'}), 400
         
-        logger.debug("--- LOG [/api/chat]: Envoi de la réponse HTML au client.\n---==================================---\n")
-        return jsonify({'success': True, 'message': response_html})
+        if file and allowed_file(file.filename):
+            filename = secure_filename(file.filename)
+            file_id = str(uuid.uuid4())
+            file_path = os.path.join(app.config['UPLOAD_FOLDER'], f"{file_id}_{filename}")
+            
+            # Sauvegarder le fichier
+            file.save(file_path)
+            
+            # Traiter le fichier pour Gemini
+            with open(file_path, 'rb') as f:
+                file_part = process_uploaded_file(f)
+            
+            if file_part:
+                # Stocker les informations du fichier en session
+                if 'uploaded_files' not in session:
+                    session['uploaded_files'] = {}
+                
+                session['uploaded_files'][file_id] = {
+                    'filename': filename,
+                    'path': file_path,
+                    'mime_type': file.content_type
+                }
+                
+                return jsonify({
+                    'success': True,
+                    'file_id': file_id,
+                    'filename': filename,
+                    'mime_type': file.content_type
+                })
+            else:
+                # Supprimer le fichier si le traitement a échoué
+                os.remove(file_path)
+                return jsonify({'error': 'Type de fichier non supporté'}), 400
         
+        return jsonify({'error': 'Type de fichier non autorisé'}), 400
+    
     except Exception as 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 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({'error': str(e)}), 500
+
+@app.route('/send_message_with_file', methods=['POST'])
+def send_message_with_file():
+    """Endpoint pour envoyer un message avec fichier attaché"""
+    def generate():
+        try:
+            data = request.get_json()
+            message = data.get('message', '')
+            model = data.get('model', 'gemini-2.5-flash')
+            thinking_enabled = data.get('thinking_enabled', True)
+            include_thoughts = data.get('include_thoughts', False)
+            file_id = data.get('file_id')
+            
+            if not message.strip():
+                yield f"data: {json.dumps({'error': 'Message vide'})}\n\n"
+                return
+            
+            # Configuration de génération
+            generation_config = get_generation_config(
+                model=model,
+                thinking_enabled=thinking_enabled,
+                include_thoughts=include_thoughts
+            )
+            
+            # Récupération du chat
+            chat = session.get('chat')
+            if not chat:
+                session['chat'] = client.chats.create(
+                    model=model,
+                    config=generation_config
+                )
+                chat = session['chat']
+            
+            # Préparation du contenu
+            contents = [message]
+            
+            # Ajout du fichier si présent
+            if file_id and 'uploaded_files' in session and file_id in session['uploaded_files']:
+                file_info = session['uploaded_files'][file_id]
+                with open(file_info['path'], 'rb') as f:
+                    file_part = process_uploaded_file(f)
+                    if file_part:
+                        contents.append(file_part)
+            
+            # Envoi du message avec streaming
+            response_stream = chat.send_message_stream(
+                contents,
+                config=generation_config
+            )
             
-        return jsonify({'success': False, 'error': f"Erreur interne: {e}"}), 500
+            # Streaming de la réponse
+            full_response = ""
+            
+            for chunk in response_stream:
+                for part in chunk.candidates[0].content.parts:
+                    if part.text:
+                        if part.thought and include_thoughts:
+                            yield f"data: {json.dumps({'type': 'thought', 'content': part.text})}\n\n"
+                        else:
+                            full_response += part.text
+                            yield f"data: {json.dumps({'type': 'text', 'content': part.text})}\n\n"
+            
+            # Message de fin
+            yield f"data: {json.dumps({'type': 'end', 'full_response': full_response})}\n\n"
+            
+        except Exception as e:
+            yield f"data: {json.dumps({'error': str(e)})}\n\n"
     
-    finally:
-        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}")
+    return Response(generate(), mimetype='text/event-stream')
 
-@app.route('/clear', methods=['POST'])
-def clear_chat():
-    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()
-    if 'XMLHttpRequest' == request.headers.get('X-Requested-With'):
-         return jsonify({'success': True, 'message': 'Historique effacé.'})
-    else:
-        flash("Conversation effacée.", "info")
-        return redirect(url_for('root'))
+@app.route('/reset_chat', methods=['POST'])
+def reset_chat():
+    """Reset la conversation"""
+    try:
+        session.pop('chat_id', None)
+        session.pop('chat', None)
+        
+        # Nettoyer les fichiers uploadés
+        if 'uploaded_files' in session:
+            for file_info in session['uploaded_files'].values():
+                try:
+                    if os.path.exists(file_info['path']):
+                        os.remove(file_info['path'])
+                except:
+                    pass
+            session.pop('uploaded_files', None)
+        
+        return jsonify({'success': True})
+    except Exception as e:
+        return jsonify({'error': str(e)}), 500
 
 if __name__ == '__main__':
-    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)
+    app.run(debug=True, host='0.0.0.0', port=5000)