Update app.py

app.py

@@ -5,7 +5,8 @@ import json
 import mimetypes
 from flask import Flask, request, session, jsonify, redirect, url_for, flash, render_template
 from dotenv import load_dotenv
-import google.generativeai as genai
+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
@@ -53,27 +54,56 @@ server_session = Session(app)
 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."
+
+# Nouveaux réglages de sécurité avec le nouveau SDK
 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"},
+    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:
         print("ERREUR: Clé API GOOGLE_API_KEY manquante dans le fichier .env")
     else:
-        genai.configure(api_key=gemini_api_key)
-        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}")
+        # Initialisation du client avec le nouveau SDK
+        genai_client = genai.Client(api_key=gemini_api_key)
+        
+        # Vérification de la disponibilité des modèles
+        try:
+            # Le nouveau SDK peut avoir une méthode différente pour lister les modèles
+            models = genai_client.list_models()
+            models_list = [model.name for model in models]
+            
+            # Vérifier si les modèles requis sont disponibles
+            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}")
+                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_models:
+            print(f"ERREUR lors de la vérification des modèles: {e_models}")
+            # En cas d'échec de la vérification des modèles, supposons que les modèles sont disponibles
+            print("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}")
@@ -86,80 +116,80 @@ def allowed_file(filename):
     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
-    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"})
+def perform_web_search_with_gemini(query, client, model_id):
+    """Effectue une recherche web via l'API Google Search intégrée à Gemini."""
     try:
-        print(f"--- LOG WEBSEARCH: Recherche Serper pour: '{query}'")
-        response = requests.post(search_url, headers=headers, data=payload, timeout=10)
-        response.raise_for_status()
-        data = response.json()
-        print("--- LOG WEBSEARCH: Résultats de recherche Serper obtenus.")
-        return data
-    except requests.exceptions.RequestException as e:
-        print(f"--- LOG WEBSEARCH: Erreur lors de la recherche web : {e}")
-        return None
-    except json.JSONDecodeError as e:
-        print(f"--- LOG WEBSEARCH: Erreur JSON Serper : {e}")
+        print(f"--- LOG WEBSEARCH: Recherche Google avec Gemini pour: '{query}'")
+        
+        # Utiliser l'outil de recherche Google intégré à Gemini
+        response = client.models.generate_content(
+            model=model_id,
+            contents=[{"role": "user", "parts": [{"text": query}]}],
+            config=types.GenerateContentConfig(
+                tools=[{"google_search": {}}]
+            )
+        )
+        
+        print("--- LOG WEBSEARCH: Résultats de recherche Google obtenus.")
+        
+        # Extraction des informations de recherche pour le débogage
+        if hasattr(response, 'candidates') and response.candidates:
+            if hasattr(response.candidates[0], 'grounding_metadata'):
+                search_queries = getattr(response.candidates[0].grounding_metadata, 'web_search_queries', None)
+                if search_queries:
+                    print(f"--- LOG WEBSEARCH: Requêtes utilisées: {search_queries}")
+                
+                grounding_chunks = getattr(response.candidates[0].grounding_metadata, 'grounding_chunks', None)
+                if grounding_chunks:
+                    sources = [getattr(chunk, 'web', None) for chunk in grounding_chunks]
+                    source_titles = [getattr(source, 'title', 'Sans titre') for source in sources if source]
+                    print(f"--- LOG WEBSEARCH: Sources utilisées: {', '.join(source_titles)}")
+        
+        return response
+        
+    except Exception as e:
+        print(f"--- LOG WEBSEARCH: Erreur lors de la recherche web avec Gemini : {e}")
         return None
 
-def format_search_results(data):
-    """Met en forme les résultats de recherche (format Markdown)."""
-    if not data: return "Aucun résultat de recherche web trouvé pertinent."
-    results = []
-    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")
-    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'):
-             results.append("\n**Attributs :**")
-             for attr, value in kg['attributes'].items(): results.append(f"- {attr}: {value}")
-             results.append("")
-    if data.get('organic'):
-        results.append("**Pages web pertinentes :**")
-        for i, item in enumerate(data['organic'][:3], 1):
-            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")
-    if data.get('peopleAlsoAsk'):
-        results.append("**Questions liées :**")
-        for i, item in enumerate(data['peopleAlsoAsk'][:2], 1): results.append(f"- {item.get('question', '')}")
-    if not results: return "Aucun résultat structuré trouvé dans la recherche web."
-    print(f"--- LOG WEBSEARCH: Résultats formatés (début): '{(' '.join(results))[:100]}...'")
-    return "\n".join(results)
+def format_search_response(response):
+    """Extrait et met en forme le texte de la réponse de recherche web."""
+    if not response: 
+        return "Aucun résultat de recherche web trouvé pertinent."
+    
+    try:
+        return response.text
+    except Exception as e:
+        print(f"--- LOG WEBSEARCH: Erreur lors de l'extraction du texte de la réponse : {e}")
+        return "Impossible d'extraire les résultats de recherche."
 
 def prepare_gemini_history(chat_history):
     """Convertit l'historique stocké en session au format attendu par Gemini API."""
-    print(f"--- DEBUG [prepare_gemini_history]: Entrée avec {len(chat_history)} messages") # LOG 1
+    print(f"--- DEBUG [prepare_gemini_history]: Entrée avec {len(chat_history)} messages")
+    
+    # Le nouveau SDK n'attend pas la même structure d'historique que l'ancien
     gemini_history = []
-    for i, message in enumerate(list(chat_history)): # Utiliser list() pour itérer sur une copie
-        role = 'user' if message.get('role') == 'user' else 'model'
+    for i, message in enumerate(list(chat_history)):
+        role = message.get('role')
         text_part = message.get('raw_text')
-        # Log détaillé pour chaque message traité
-        print(f"  [prepare_gemini_history] Message {i} (rôle session: {message.get('role')}, rôle gemini: {role}): raw_text présent? {'Oui' if text_part is not None else 'NON'}, contenu début: '{str(text_part)[:60]}...'") # LOG 2
-
-        if text_part: # Important: Ne pas ajouter de messages vides à l'historique Gemini
-            parts = [text_part]
-            gemini_history.append({'role': role, 'parts': parts})
+        
+        print(f"  [prepare_gemini_history] Message {i} (rôle: {role}): raw_text présent? {'Oui' if text_part is not None else 'NON'}, contenu début: '{str(text_part)[:60]}...'")
+        
+        if text_part:  # Important: Ne pas ajouter de messages vides
+            # Format corrigé pour le nouveau SDK
+            if role == 'user':
+                gemini_history.append({
+                    "role": "user",
+                    "parts": [{"text": text_part}]
+                })
+            else:  # assistant
+                gemini_history.append({
+                    "role": "model",
+                    "parts": [{"text": text_part}]
+                })
         else:
-            # Log si un message est ignoré car vide
-            print(f"  AVERTISSEMENT [prepare_gemini_history]: raw_text vide ou absent pour le message {i}, ignoré pour l'historique Gemini.") # LOG 3
-
-    print(f"--- DEBUG [prepare_gemini_history]: Sortie avec {len(gemini_history)} messages formatés pour Gemini") # LOG 4
+            print(f"  AVERTISSEMENT [prepare_gemini_history]: raw_text vide ou absent pour le message {i}, ignoré pour l'historique Gemini.")
+    
+    print(f"--- DEBUG [prepare_gemini_history]: Sortie avec {len(gemini_history)} messages formatés pour Gemini")
     return gemini_history
 
 # --- Routes Flask ---
@@ -173,18 +203,14 @@ def root():
 @app.route('/api/history', methods=['GET'])
 def get_history():
     """Fournit l'historique de chat stocké en session au format JSON."""
-    print("\n--- DEBUG [/api/history]: Début requête GET ---") # LOG 5
+    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é de la session serveur: {len(current_history)} messages.") # LOG 6
-
-    # Optionnel: Afficher la structure brute pour un debug profond
-    # print("  [/api/history]: Contenu brut de l'historique session:")
-    # pprint.pprint(current_history)
+    print(f"  [/api/history]: Historique récupéré de la session serveur: {len(current_history)} messages.")
 
     for i, msg in enumerate(current_history):
          # Vérifier la structure de chaque message récupéré
@@ -195,9 +221,9 @@ def get_history():
              })
          else:
              # Log si un message dans la session est mal formé
-             print(f"  AVERTISSEMENT [/api/history]: Format invalide dans l'historique session au message {i}: {msg}") # LOG 7
+             print(f"  AVERTISSEMENT [/api/history]: Format invalide dans l'historique session au message {i}: {msg}")
 
-    print(f"  [/api/history]: Historique préparé pour le frontend: {len(display_history)} messages.") # LOG 8
+    print(f"  [/api/history]: Historique préparé pour le frontend: {len(display_history)} messages.")
     return jsonify({'success': True, 'history': display_history})
 
 @app.route('/api/chat', methods=['POST'])
@@ -206,7 +232,7 @@ def chat_api():
     print(f"\n---===================================---")
     print(f"--- DEBUG [/api/chat]: Nouvelle requête POST ---")
 
-    if not GEMINI_CONFIGURED:
+    if not GEMINI_CONFIGURED or not genai_client:
         print("--- ERREUR [/api/chat]: Tentative d'appel sans configuration Gemini valide.")
         return jsonify({'success': False, 'error': "Le service IA n'est pas configuré correctement."}), 503
 
@@ -228,14 +254,10 @@ def chat_api():
     # --- Log de l'état de l'historique AVANT toute modification ---
     if 'chat_history' not in session:
         session['chat_history'] = []
-    history_before_user_add = list(session.get('chat_history', [])) # Copie pour le log
-    print(f"--- DEBUG [/api/chat]: Historique en session AVANT ajout user message: {len(history_before_user_add)} messages") # LOG 9
-    # Optionnel: Afficher les derniers messages pour voir le contexte précédent
-    # if history_before_user_add:
-    #     print("  [/api/chat]: Dernier(s) message(s) avant ajout:")
-    #     pprint.pprint(history_before_user_add[-2:]) # Afficher les 2 derniers
-
-    uploaded_gemini_file = None
+    history_before_user_add = list(session.get('chat_history', []))
+    print(f"--- DEBUG [/api/chat]: Historique en session AVANT ajout user message: {len(history_before_user_add)} messages")
+
+    uploaded_file_part = None
     uploaded_filename = None
     filepath_to_delete = None
 
@@ -251,9 +273,20 @@ def chat_api():
                 uploaded_filename = filename
                 print(f"  [/api/chat]: Fichier '{filename}' sauvegardé dans '{filepath}'")
                 mime_type = mimetypes.guess_type(filepath)[0] or 'application/octet-stream'
-                print(f"  [/api/chat]: Upload Google AI (Mime: {mime_type})...")
-                uploaded_gemini_file = genai.upload_file(path=filepath, mime_type=mime_type)
-                print(f"  [/api/chat]: Fichier Google AI '{uploaded_gemini_file.name}' uploadé.")
+                print(f"  [/api/chat]: Préparation du fichier pour Gemini (Mime: {mime_type})...")
+                
+                # Avec le nouveau SDK, la méthode d'upload a été mise à jour
+                with open(filepath, "rb") as f:
+                    file_data = f.read()
+                
+                # Création d'une partie de type fichier pour l'API
+                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/upload fichier '{filename}': {e}")
                 if filepath_to_delete and os.path.exists(filepath_to_delete):
@@ -280,147 +313,153 @@ def chat_api():
     session['chat_history'].append(user_history_entry)
 
     # --- Log de l'état de l'historique APRES ajout du message utilisateur ---
-    history_after_user_add = list(session.get('chat_history', [])) # Nouvelle copie
-    print(f"--- DEBUG [/api/chat]: Historique en session APRES ajout user message: {len(history_after_user_add)} messages") # LOG 10
-    # print("  [/api/chat]: Dernier message ajouté (user):")
-    # pprint.pprint(history_after_user_add[-1])
+    history_after_user_add = list(session.get('chat_history', []))
+    print(f"--- DEBUG [/api/chat]: Historique en session APRES ajout user message: {len(history_after_user_add)} messages")
 
+    # --- Sélection du modèle ---
+    selected_model_name = MODEL_PRO if use_advanced else MODEL_FLASH
 
-    # --- Préparation des 'parts' pour l'appel Gemini ACTUEL ---
-    current_gemini_parts = []
+    # --- Préparation des contenus pour l'appel Gemini ---
+    final_prompt_for_gemini = raw_user_text
+    
     # Gérer le cas où seul un fichier est envoyé
-    if uploaded_gemini_file 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
-         current_gemini_parts.append(uploaded_gemini_file)
-         current_gemini_parts.append(final_prompt_for_gemini)
-         print(f"  [/api/chat]: Fichier seul détecté, prompt généré: '{final_prompt_for_gemini}'")
-    elif uploaded_gemini_file and raw_user_text:
-        final_prompt_for_gemini = raw_user_text
-        current_gemini_parts.append(uploaded_gemini_file)
-        current_gemini_parts.append(final_prompt_for_gemini)
-    else: # Seulement du texte (ou ni texte ni fichier valide, géré plus bas)
+    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
-        if final_prompt_for_gemini:
-             current_gemini_parts.append(final_prompt_for_gemini)
+        print(f"  [/api/chat]: Fichier seul détecté, prompt généré: '{final_prompt_for_gemini}'")
 
-    # --- Recherche Web ---
-    if use_web_search and final_prompt_for_gemini: # Assurer qu'il y a du texte à chercher
+    # --- Recherche Web si demandée ---
+    web_search_results = None
+    if use_web_search and final_prompt_for_gemini:
         print(f"--- LOG [/api/chat]: Activation recherche web pour: '{final_prompt_for_gemini[:60]}...'")
-        search_data = perform_web_search(final_prompt_for_gemini)
-        if search_data:
-            formatted_results = format_search_results(search_data)
-            enriched_prompt = f"""Voici la question originale de l'utilisateur:\n"{final_prompt_for_gemini}"\n\nInformations pertinentes de recherche web:\n--- DEBUT RESULTATS WEB ---\n{formatted_results}\n--- FIN RESULTATS WEB ---\n\nRéponds à la question originale en te basant sur ces informations ET ta connaissance générale."""
-            # Remplacer le dernier élément texte dans current_gemini_parts
-            if current_gemini_parts and isinstance(current_gemini_parts[-1], str):
-                current_gemini_parts[-1] = enriched_prompt
-                final_prompt_for_gemini = enriched_prompt # Mettre à jour pour les logs suivants
-            print(f"  [/api/chat]: Prompt enrichi avec recherche web.")
-        else:
-            print(f"  [/api/chat]: Recherche web sans résultat pertinent ou erreur.")
-
-    # Vérifier si on a quelque chose à envoyer
-    if not current_gemini_parts:
-        print("--- ERREUR [/api/chat]: Aucune donnée (texte ou fichier valide) à envoyer après traitement.")
-        if session.get('chat_history'): session['chat_history'].pop() # Retirer le user message vide/inutile
-        return jsonify({'success': False, 'error': "Impossible d'envoyer une requête vide."}), 400
+        web_search_response = perform_web_search_with_gemini(final_prompt_for_gemini, genai_client, selected_model_name)
+        if web_search_response:
+            web_search_results = format_search_response(web_search_response)
+            print(f"  [/api/chat]: Résultats de recherche obtenus.")
 
     # --- Appel à l'API Gemini ---
     try:
+        print(f"--- DEBUG [/api/chat]: Préparation de l'envoi à l'API Gemini (Modèle: {selected_model_name}) ---")
+        
         # Préparer l'historique des messages PRÉCÉDENTS pour Gemini
-        # Important: Utiliser une copie de l'historique SANS le dernier message utilisateur ajouté
-        history_for_gemini_prep = list(session.get('chat_history', []))[:-1]
+        history_for_gemini_prep = list(session.get('chat_history', []))[:-1]  # Sans le dernier message utilisateur
         gemini_history_to_send = prepare_gemini_history(history_for_gemini_prep)
-
-        # Construire le contenu complet pour l'appel
-        contents_for_gemini = gemini_history_to_send + [{'role': 'user', 'parts': current_gemini_parts}]
-
-        # --- LOG DÉTAILLÉ : Ce qui est envoyé à l'API ---
-        selected_model_name = MODEL_PRO if use_advanced else MODEL_FLASH
-        print(f"--- DEBUG [/api/chat]: Préparation de l'envoi à l'API Gemini (Modèle: {selected_model_name}) ---") # LOG 11
-        print(f"  Nombre total de tours (historique + actuel): {len(contents_for_gemini)}") # LOG 12a
-        print(f"  Nombre de messages d'historique formatés envoyés: {len(gemini_history_to_send)}") # LOG 12b
-        print(f"  Contenu détaillé des 'parts' envoyées:") # LOG 13
-        for i, turn in enumerate(contents_for_gemini):
-            role = turn.get('role')
-            parts_details = []
-            for part in turn.get('parts', []):
-                if isinstance(part, str):
-                    parts_details.append(f"Text({len(part)} chars): '{part[:60].replace(chr(10), ' ')}...'") # Remplacer newline pour log sur 1 ligne
-                elif hasattr(part, 'name') and hasattr(part, 'mime_type'):
-                    parts_details.append(f"File(name={part.name}, mime={part.mime_type})")
+        
+        # Construire le contenu pour l'appel avec le nouveau SDK
+        contents = gemini_history_to_send.copy()  # Commencer avec l'historique
+        
+        # Ajouter le message actuel de l'utilisateur
+        current_user_parts = []
+        
+        # Si un fichier est présent, l'ajouter
+        if uploaded_file_part:
+            current_user_parts.append(uploaded_file_part)
+        
+        # Ajouter le texte du message
+        if final_prompt_for_gemini:
+            current_user_parts.append({"text": final_prompt_for_gemini})
+        
+        if current_user_parts:
+            contents.append({
+                "role": "user",
+                "parts": current_user_parts
+            })
+        
+        # Log détaillé de ce qui est envoyé
+        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): '{part['text'][:50]}...'")
+                elif isinstance(part, dict) and "inline_data" in part:
+                    parts_info.append(f"File(mime={part['inline_data']['mime_type']})")
                 else:
-                    parts_details.append(f"UnknownPart({type(part)})")
-            print(f"    Turn {i} (role: {role}): {', '.join(parts_details)}")
-        print("--------------------------------------------------------------------")
-
-        # Créer l'instance du modèle et appeler l'API
-        active_model = genai.GenerativeModel(
-            model_name=selected_model_name,
-            safety_settings=SAFETY_SETTINGS,
-            system_instruction=SYSTEM_INSTRUCTION
+                    parts_info.append(f"Part({type(part)})")
+            
+            print(f"    Message {i} (role: {role}): {', '.join(parts_info)}")
+        
+        # Configuration de l'appel à l'API
+        generate_config = types.GenerateContentConfig(
+            system_instruction=SYSTEM_INSTRUCTION,
+            safety_settings=SAFETY_SETTINGS
         )
+        
+        # Ajouter la configuration de recherche web si demandée
+        if use_web_search:
+            generate_config.tools = [{"google_search": {}}]
+        
+        # Appel à l'API avec le nouveau SDK
         print(f"--- LOG [/api/chat]: Envoi de la requête à {selected_model_name}...")
-        response = active_model.generate_content(contents_for_gemini)
-
+        response = genai_client.models.generate_content(
+            model=selected_model_name,
+            contents=contents,
+            config=generate_config
+        )
+        
         # --- Traitement de la réponse (avec logs) ---
         response_text_raw = ""
         response_html = ""
+        
         try:
-            if response.parts:
-                response_text_raw = response.text # .text concatène les parts textuelles
+            # Extraction du texte de la réponse avec le nouveau SDK
+            if hasattr(response, 'text'):
+                response_text_raw = response.text
                 print(f"--- LOG [/api/chat]: Réponse reçue de Gemini (brute, début): '{response_text_raw[:100]}...'")
+            elif hasattr(response, 'parts'):
+                response_text_raw = ' '.join([str(part) for part in response.parts])
+                print(f"--- LOG [/api/chat]: Réponse extraite des parts: '{response_text_raw[:100]}...'")
             else:
-                feedback_info = f"Feedback: {response.prompt_feedback}" if response.prompt_feedback else "Pas de feedback détaillé."
-                print(f"--- AVERTISSEMENT [/api/chat]: Réponse Gemini sans 'parts'. {feedback_info}")
-                if response.prompt_feedback and response.prompt_feedback.block_reason:
-                    reason = response.prompt_feedback.block_reason.name
-                    response_text_raw = f"Désolé, ma réponse a été bloquée ({reason})."
-                    if reason == 'SAFETY' and response.prompt_feedback.safety_ratings:
-                        blocked_cats = [r.category.name for r in response.prompt_feedback.safety_ratings if r.probability.name not in ['NEGLIGIBLE', 'LOW']]
-                        if blocked_cats: response_text_raw += f" Catégories: {', '.join(blocked_cats)}."
+                # Gestion des erreurs de sécurité ou autres
+                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."
+                    response_text_raw = "Désolé, je n'ai pas pu générer de réponse."
+                
                 print(f"  [/api/chat]: Message d'erreur généré: '{response_text_raw}'")
-
+            
             # Conversion Markdown
             response_html = markdown.markdown(response_text_raw, extensions=['fenced_code', 'tables', 'nl2br'])
             if response_html != response_text_raw:
-                 print(f"  [/api/chat]: Réponse convertie en HTML.")
-
-        except ValueError as e:
-            print(f"--- ERREUR [/api/chat]: Impossible d'extraire le texte de la réponse Gemini. Erreur: {e}")
-            print(f"  Réponse brute: {response}")
-            response_text_raw = "Désolé, erreur interne lors de la lecture de la réponse."
-            response_html = markdown.markdown(response_text_raw)
+                print(f"  [/api/chat]: Réponse convertie en HTML.")
+                
         except Exception as e_resp:
-            print(f"--- ERREUR [/api/chat]: INATTENDUE lors traitement réponse Gemini : {e_resp}")
+            print(f"--- ERREUR [/api/chat]: Erreur lors du traitement de la réponse Gemini : {e_resp}")
             print(f"  Réponse brute: {response}")
             response_text_raw = f"Désolé, erreur inattendue ({type(e_resp).__name__})."
             response_html = markdown.markdown(response_text_raw)
-
+        
         # --- Ajout de la réponse Assistant à l'historique de session ---
         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 liste avant ajout assistant! Réinitialisation.")
             session['chat_history'] = [user_history_entry] # Garder au moins user msg
+        
         session['chat_history'].append(assistant_history_entry)
-
+        
         # --- Log de l'état final de l'historique pour ce tour ---
         history_final_turn = list(session.get('chat_history', []))
-        print(f"--- DEBUG [/api/chat]: Historique en session FINAL après ajout assistant: {len(history_final_turn)} messages") # LOG 14
-        # print("  [/api/chat]: Dernier message ajouté (assistant):")
-        # pprint.pprint(history_final_turn[-1])
-
+        print(f"--- DEBUG [/api/chat]: Historique en session FINAL après ajout assistant: {len(history_final_turn)} messages")
+        
         # --- Renvoyer la réponse au frontend ---
         print(f"--- LOG [/api/chat]: Envoi de la réponse HTML au client.")
         print(f"---==================================---\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}")
         # Tentative de retrait du dernier message utilisateur en cas d'erreur
@@ -433,21 +472,12 @@ def chat_api():
                 else:
                     print("  [/api/chat]: Dernier message n'était pas 'user', historique non modifié après erreur.")
             except Exception as pop_e:
-                 print(f"  Erreur lors tentative retrait message user: {pop_e}")
+                print(f"  Erreur lors tentative retrait message user: {pop_e}")
         print(f"---==================================---\n")
         return jsonify({'success': False, 'error': f"Erreur interne: {e}"}), 500
-
+    
     finally:
-        # --- Nettoyage des fichiers (Google AI et local) ---
-        # Nettoyage Google AI File
-        if uploaded_gemini_file:
-             try:
-                 print(f"--- LOG [/api/chat FINALLY]: Tentative suppression fichier Google AI : {uploaded_gemini_file.name}")
-                 genai.delete_file(uploaded_gemini_file.name)
-                 print(f"  [/api/chat FINALLY]: Fichier Google AI '{uploaded_gemini_file.name}' supprimé.")
-             except Exception as e_del_gcp:
-                 print(f"  AVERTISSEMENT [/api/chat FINALLY]: Échec suppression fichier Google AI '{uploaded_gemini_file.name}': {e_del_gcp}")
-        # Nettoyage Fichier Local
+        # --- Nettoyage des fichiers locaux ---
         if filepath_to_delete and os.path.exists(filepath_to_delete):
             try:
                 os.remove(filepath_to_delete)