Update src/streamlit_app.py

src/streamlit_app.py

@@ -12,6 +12,7 @@ from io import BytesIO # Pour lire les données binaires de l'image
 import google.generativeai as genai
 
 # Import DuckDuckGo Search (for web search feature)
+# Assurez-vous d'avoir installé cette bibliothèque : pip install duckduckgo_search
 from duckduckgo_search import DDGS # Importe la classe DDGS
 
 # -----------------------------------------------------------------------------
@@ -29,7 +30,7 @@ HF_BASE_API_URL = "https://api-inference.huggingface.co/models/"
 # -----------------------------------------------------------------------------
 # Structure: {'id': 'model_id', 'name': 'Display Name', 'provider': 'huggingface'/'google', 'type': 'text'/'t2i', 'params': {...} }
 AVAILABLE_MODELS = [
-    # --- Google Text Models (Only keeping 1.5 Flash/Pro as requested) ---
+    # --- Google Text Models (Only keeping Flash as requested) ---
     {
         "id": "gemini-1.5-flash-latest",
         "name": "Gemini 1.5 Flash (Google)",
@@ -41,27 +42,39 @@ AVAILABLE_MODELS = [
             "top_p": 0.9,
         },
     },
-    {
-        "id": "gemini-1.5-pro-latest",
-        "name": "Gemini 1.5 Pro (Google)",
+     {
+        "id": "gemini-2.0-flash-lite-001", # Ajouté comme demandé
+        "name": "Gemini 2.0 Flash Lite 001 (Google)",
         "provider": "google",
-        "type": "text",
+        "type": "text", # Supposé compatible pour le chat texte
         "params": {
-            "max_new_tokens": 200,
-            "temperature": 0.6,
-            "top_p": 0.9,
+             "max_new_tokens": 200,
+             "temperature": 0.6,
+             "top_p": 0.9,
         },
     },
-    # Removed: Mistral (Hugging Face Text)
-    # Removed: Stable Diffusion XL Base 1.0 (Hugging Face T2I)
+     {
+         "id": "gemini-2.0-flash-preview-image-generation", # Ajouté comme demandé - NOTE : Son comportement exact comme modèle de chat texte peut varier.
+         "name": "Gemini 2.0 Flash Preview Image Gen (Google)",
+         "provider": "google",
+         "type": "text", # Supposé compatible pour le chat texte malgré son nom
+         "params": { # Paramètres par défaut pour le texte
+             "max_new_tokens": 200,
+             "temperature": 0.6,
+             "top_p": 0.9,
+         },
+     },
+    # Retiré : gemini-1.5-pro-latest, gemini-pro, gemini-2.5-flash-preview, gemini-2.5-pro-preview
+    # Retiré : Mistral (Hugging Face Text)
+    # Retiré : Stable Diffusion XL Base 1.0 (Hugging Face T2I) et les autres SD.
 ]
 
-# Separate models lists by type (still useful for default selection and filtering params)
+# Separate models lists by type (still potentially useful for future expansion)
 MODELS_BY_TYPE = {m_type: [m for m in AVAILABLE_MODELS if m['type'] == m_type] for m_type in set(m['type'] for m in AVAILABLE_MODELS)}
 
 # Default task is now fixed to 'text'
 DEFAULT_TASK = 'text'
-# Find the first text model as default (will be Gemini 1.5 Flash now due to ordering)
+# Find the first text model as default
 first_text_model = next((m for m in AVAILABLE_MODELS if m['type'] == DEFAULT_TASK), None)
 if first_text_model:
     DEFAULT_MODEL_ID = first_text_model['id']
@@ -127,6 +140,7 @@ if '_prev_model_id_before_selectbox' not in st.session_state:
 if 'enable_web_search' not in st.session_state:
     st.session_state.enable_web_search = False
 
+
 # -----------------------------------------------------------------------------
 # Helper pour formater les exports (Adapté pour images)
 # -----------------------------------------------------------------------------
@@ -155,9 +169,9 @@ def format_history_to_json(chat_history: list[dict]) -> str:
 
         if export_msg["type"] == "text":
             export_msg["content"] = message.get("content", "")
-        elif export_msg["type"] == "t2i_prompt": # User prompt for T2I
+        elif export_msg["type"] == "t2i_prompt": # User prompt for T2I (kept for handling potential old history)
              export_msg["content"] = message.get("content", "")
-        elif export_msg["type"] == "t2i" and "prompt" in message: # AI image response
+        elif export_msg["type"] == "t2i" and "prompt" in message: # AI image response (kept for handling potential old history)
             export_msg["prompt"] = message["prompt"]
             export_msg["image_placeholder"] = "(Image non incluse dans l'export JSON)" # Indicate image was here
             if "content" in message: # Include error message if it was an error T2I response
@@ -181,9 +195,9 @@ def format_history_to_md(chat_history: list[dict]) -> str:
         lines.append(f"### {role_label}\n\n")
         if content_type == "text":
             lines.append(f"{message.get('content', '')}\n\n")
-        elif content_type == "t2i_prompt":
+        elif content_type == "t2i_prompt": # Kept for handling potential old history
              lines.append(f"*Prompt image:* {message.get('content', '')}\n\n")
-        elif content_type == "t2i": # AI image response
+        elif content_type == "t2i": # Kept for handling potential old history
             prompt_text = message.get('prompt', 'Pas de prompt enregistré')
             error_text = message.get('content', '') # Potential error message
             lines.append(f"*Image générée (prompt: {prompt_text})*\n")
@@ -200,195 +214,55 @@ def format_history_to_md(chat_history: list[dict]) -> str:
 # -----------------------------------------------------------------------------
 # LLM API helper (Unified call logic)
 # -----------------------------------------------------------------------------
-# This function is specifically for text prompt building for Mistral-style models
-def build_mistral_prompt(system_message: str, chat_history_for_prompt: list[dict]) -> str:
-    """
-    Builds a prompt string suitable for Mistral-style instruction models using the
-    chat history (text messages only).
-    Assumes chat_history_for_prompt contains the messages relevant
-    to the model turns, starting with the first actual user turn (potentially including system)
-    and ending with the current user message.
-    """
-    formatted_prompt = ""
-    system_message_added = False
-
-    # Only include text messages in history for prompt building
-    # Filter out non-text messages and the initial assistant starter message if it's not the only one
-    text_chat_history = [
-        msg for msg in chat_history_for_prompt
-        if msg.get("type", "text") == "text" # Only include messages explicitly typed as 'text'
-        and not (msg['role'] == 'assistant' and msg['content'] == st.session_state.starter_message and len(chat_history_for_prompt) > 1)
-    ]
-
-
-    for message in text_chat_history:
-        if message["role"] == "user":
-            if not system_message_added and system_message:
-                formatted_prompt += f"<s>[INST] <<SYS>>\n{system_message}\n<</SYS>>\n\n{message['content']} [/INST]"
-                system_message_added = True
-            else:
-                # If system message already added or not present, just add the user turn
-                # If the previous turn was assistant, this starts a new user turn
-                 if formatted_prompt.endswith("</s>"):
-                      formatted_prompt += f"<s>[INST] {message['content']} [/INST]"
-                 else:
-                      # This case might happen if the very first message is user and no system message,
-                      # or if there's an unexpected sequence. Append directly within INST.
-                      # This might not be the perfect Mistral format for all cases but handles simple turns.
-                      formatted_prompt += f"<s>[INST] {message['content']} [/INST]"
-
-
-        elif message["role"] == "assistant":
-            # Add assistant response directly after the corresponding user INST block
-            # Ensure the prompt ends with [/INST] before adding assistant response
-            if formatted_prompt.endswith("[/INST]"):
-                 formatted_prompt += f" {message['content']}</s>"
-            # else: If the prompt doesn't end with [/INST], the sequence is likely wrong
-            # We will skip this assistant message for prompt building.
-
-
-    return formatted_prompt
-
+# Removed build_mistral_prompt as no Mistral models
 
 def call_hf_inference(model_id: str, payload_inputs: any, params: dict, model_type: str) -> any:
     """
     Calls the Hugging Face Inference API for either text generation or text-to-image.
-    payload_inputs is the main input (string for text, string for t2i prompt).
-    params depends on the model_type.
-    Returns string for text, bytes for image, or error string.
+    This function is now only relevant for T2I calls if you were to add back T2I models.
     """
     if not HUGGINGFACEHUB_API_TOKEN:
         return "Erreur d'API Hugging Face: Le token HUGGINGFACEHUB_API_TOKEN est introuvable."
 
     headers = {"Authorization": f"Bearer {HUGGINGFACEHUB_API_TOKEN}"}
-    url = f"{HF_BASE_API_URL}{model_id}" # Corrected URL to include model_id
-
-    payload = {}
-    response_parser = None
+    url = f"{HF_BASE_API_URL}{model_id}"
 
+    # Since we removed HF text models, this branch is not expected to be hit in this config.
+    # If you add HF text models back, ensure the prompt building is done by the caller.
     if model_type == 'text':
-        payload = {
-            "inputs": payload_inputs, # The prompt string built elsewhere
-            "parameters": {
-                "max_new_tokens": params.get("max_new_tokens", 200),
-                "temperature": params.get("temperature", 0.6),
-                "top_p": params.get("top_p", 0.9),
-                "return_full_text": False,
-                "num_return_sequences": 1,
-                "do_sample": params.get("temperature", 0.6) > 1e-2, # Do sampling if temperature > 0
-            },
-            "options": {"wait_for_model": True, "use_cache": False}
-        }
-        def parse_text_response(response_data):
-            if isinstance(response_data, list) and response_data and "generated_text" in response_data[0]:
-                return response_data[0]["generated_text"].strip()
-            else:
-                return f"Erreur API Hugging Face (Format): Réponse texte inattendue - {response_data}"
-        response_parser = parse_text_response
-        response_is_json = True # Expected response format
+         # This case should not be hit with the current AVAILABLE_MODELS list
+         st.error("Erreur interne: Modèle texte Hugging Face non pris en charge dans cette configuration.")
+         return {"role": "assistant", "content": "Erreur interne: Modèle texte Hugging Face non pris en charge dans cette configuration.", "type": "text"}
+
 
     elif model_type == 't2i':
-        payload = {
-            "inputs": payload_inputs, # The prompt string (user input)
-            "parameters": {
-                "negative_prompt": params.get("negative_prompt", ""),
-                "num_inference_steps": params.get("num_inference_steps", 50),
-                "guidance_scale": params.get("guidance_scale", 7.5),
-                "height": params.get("image_height", 512),
-                "width": params.get("image_width", 512),
-            },
-            "options": {"wait_for_model": True, "use_cache": False}
-        }
-        def parse_t2i_response(response):
-            # Response for T2I is binary image data
-            if response.content:
-                return response.content # Return bytes
-            else:
-                return f"Erreur API Hugging Face (T2I): Réponse image vide ou inattendue."
-        response_parser = parse_t2i_response
-        response_is_json = False # Expected response format is binary/image
+        # This case should not be hit with the current AVAILABLE_MODELS list
+        st.error("Erreur interne: Modèle Text-to-Image Hugging Face non pris en charge dans cette configuration.")
+        return {"role": "assistant", "content": "Erreur interne: Modèle Text-to-Image Hugging Face non pris en charge dans cette configuration.", "type": "text", "prompt": payload_inputs}
 
     else:
         return f"Erreur interne: Type de modèle Hugging Face '{model_type}' inconnu."
 
 
-    if response_parser is None: # Should not happen if block above is complete
-        return f"Erreur interne: Le type de modèle '{model_type}' n'a pas de parseur de réponse défini."
-
-    try:
-        # For T2I, `json` parameter in requests post is not used, `data` is used with the raw prompt bytes.
-        # For text, `json` is used.
-        if model_type == 'text':
-            response = requests.post(url, headers=headers, json=payload, timeout=300)
-        elif model_type == 't2i':
-            # `inputs` is the prompt string in payload, but for HF Inference API for T2I,
-            # sometimes the prompt is passed as raw `data` in the request body.
-            # However, the structure of payload for text-to-image is typically JSON as well.
-            # The API for stable-diffusion-xl-base-1.0 expects a JSON payload.
-            response = requests.post(url, headers=headers, json=payload, timeout=300)
-
-        response.raise_for_status() # Raise an HTTPError for bad responses (4xx or 5xx)
-
-        # Check content type based on expected format
-        if response_is_json:
-            # Expecting JSON (e.g., text models)
-            if 'application/json' in response.headers.get('Content-Type', '').lower():
-                response_data = response.json()
-                return response_parser(response_data)
-            else:
-                # Received non-JSON when JSON was expected
-                return f"Erreur API Hugging Face: Type de contenu inattendu ({response.headers.get('Content-Type', 'N/A')}) - attendu JSON.\nResponse content: {response.text[:500]}..." # Include some response text for debugging
-        else: # Expecting binary/image (e.g., t2i models)
-            if 'image/' in response.headers.get('Content-Type', '').lower() or 'binary' in response.headers.get('Content-Type', '').lower() or ('application/json' not in response.headers.get('Content-Type', '').lower() and response.content):
-                return response_parser(response) # Pass the full response object or just content if parser needs it
-            elif 'application/json' in response.headers.get('Content-Type', '').lower():
-                # Sometimes errors come back as JSON even for binary endpoints
-                error_detail = response.json()
-                error_message = error_detail.get('error', str(error_detail))
-                if isinstance(error_message, list): error_message = ". ".join(error_message)
-                estimated_time = error_detail.get('estimated_time', None)
-                if estimated_time:
-                    return f"Erreur API Hugging Face ({response.status_code}): {error_message}. Le modèle est peut-être en chargement, veuillez réessayer dans environ {_format_time(estimated_time)}."
-                return f"Erreur API Hugging Face ({response.status_code}): {error_message}"
-            else:
-                # Received unexpected content type
-                return f"Erreur API Hugging Face: Type de contenu inattendu ({response.headers.get('Content-Type', 'N/A')}) - attendu image/binary.\nResponse content: {response.text[:500]}..." # Include some response text for debugging
+    # The code below this point would only be reached if you added back HF models.
+    # The structure is kept but not actively used in this config.
+    payload = {}
+    response_parser = None
+    response_is_json = False # Default to False for safety
 
+    # ... (rest of the hf inference logic is now effectively unreachable) ...
+    # To avoid linting errors or confusion, let's just make it return an error for any other type.
+    return f"Erreur interne: Type de modèle Hugging Face '{model_type}' non géré dans l'appel API."
 
-    except requests.exceptions.Timeout:
-        return "Erreur API Hugging Face: Délai d'attente dépassé pour la requête (300s). Le modèle est peut-être lent à charger. Veuillez réessayer."
-    except requests.exceptions.ConnectionError as e:
-        return f"Erreur API Hugging Face: Impossible de se connecter à l'API. Détails: {e}"
-    except requests.exceptions.HTTPError as e:
-        # Try to parse error details if available, otherwise display status code and text
-        try:
-            if 'application/json' in e.response.headers.get('Content-Type', '').lower():
-                error_detail = e.response.json()
-                error_message = error_detail.get('error', str(error_detail))
-                if isinstance(error_message, list): error_message = ". ".join(error_message)
-                estimated_time = error_detail.get('estimated_time', None)
-                if estimated_time:
-                    return f"Erreur API Hugging Face ({e.response.status_code}): {error_message}. Le modèle est peut-être en chargement, veuillez réessayer dans environ {_format_time(estimated_time)}."
-                return f"Erreur API Hugging Face ({e.response.status_code}): {error_message}"
-            else:
-                # Non-JSON error response
-                return f"Erreur API Hugging Face ({e.response.status_code}): {e.response.text[:500]}..." # Limit raw text length
-
-        except Exception: # Catch any error during JSON decoding or key access
-            return f"Erreur API Hugging Face ({e.response.status_code}): Impossible d'obtenir les détails de l'erreur. Réponse brute: {e.response.text[:200]}..." # Limit raw text length
-    except Exception as e:
-        return f"Erreur inconnue lors de l'appel API Hugging Face: {e}"
 
 
 def call_google_api(model_id: str, system_message: str, chat_history_for_api: list[dict], params: dict) -> str:
     """
     Calls the Google Generative AI API (Text models only).
-    Note: The system_message parameter is included here for consistency,
-    but it is NOT passed to generate_content to avoid the 'unexpected keyword argument' error.
-    This means the system message is currently NOT applied to Google models.
+    Note: The system_message is included for consistency but IGNORED in the API call.
     """
     if not GOOGLE_API_KEY:
-        return "Erreur d'API Google: Le token GOOGLE_API_KEY est introuvable."
+        return "Erreur d'API Google: La clé API Google est introuvable."
 
     try:
         genai.configure(api_key=GOOGLE_API_KEY)
@@ -400,45 +274,31 @@ def call_google_api(model_id: str, system_message: str, chat_history_for_api: li
 
         # Prepare history for the Gemini API
         # The standard format is a list of dicts: [{'role': 'user', 'parts': [...]}, {'role': 'model', 'parts': ...]}]
-        # `chat_history_for_api` here is the list of messages relevant to the model turns (filtered by text type and excluding initial assistant message).
+        # `chat_history_for_api` here is the list of messages relevant to the model turns (filtered by text type).
         gemini_history_parts = []
 
-        # === IMPORTANT ===
-        # The 'system_instruction' parameter has been removed from generate_content
-        # to fix the 'unexpected keyword argument' error you reported.
-        # This means the system_message defined in the sidebar will NOT be used
-        # by Google models with this version of the code.
-        # If 'system_instruction' becomes supported by your model version in the future,
-        # you can re-add it here: system_instruction=system_message if system_message else None
-        # But for now, we pass only contents and generation_config.
+        # System message is ignored for API call (as per previous fix)
 
         for msg in chat_history_for_api:
-            # Only include text messages in history sent to Google Text models
-            # We assume chat_history_for_api already contains only text messages for this function.
-            if msg.get("type", "text") == "text": # Double check type safety
+            if msg.get("type", "text") == "text":
                 # Map roles: Streamlit 'user' -> Google 'user', Streamlit 'assistant' -> Google 'model'
                 role = 'user' if msg['role'] == 'user' else 'model'
                 gemini_history_parts.append({"role": role, "parts": [msg['content']]})
-            # Note: Gemini can handle multimodal (`parts` can contain text/image/etc.),
-            # but this specific `call_google_api` function is currently designed
-            # for text-only history to ensure compatibility with text models.
 
         generation_config = genai.types.GenerationConfig(
             max_output_tokens=params.get("max_new_tokens", 200),
             temperature=params.get("temperature", 0.6),
             top_p=params.get("top_p", 0.9),
-            # top_k=params.get("top_k", None), # Gemini doesn't use top_k directly in config, but is part of nucleus sampling via top_p
         )
 
-        # Call generate_content *without* the 'system_instruction' argument to fix the error
+        # Call generate_content *without* the 'system_instruction' argument
         response = model.generate_content(
             contents=gemini_history_parts,
             generation_config=generation_config,
-            request_options={'timeout': 180} # Increased timeout slightly
+            request_options={'timeout': 180}
         )
 
         # Process the response
-        # Access response text safely, handling potential empty responses or blocks
         if response.candidates:
             if response.candidates[0].content and response.candidates[0].content.parts:
                 generated_text = "".join(part.text for part in response.candidates[0].content.parts)
@@ -454,7 +314,7 @@ def call_google_api(model_id: str, system_message: str, chat_history_for_api: li
             return f"API Google: Votre message a été bloqué ({response.prompt_feedback.block_reason}). Raison détaillée: {response.prompt_feedback.safety_ratings}"
         else:
             # No candidates and no block feedback - unknown error
-            return f"Erreur API Google: Aucune réponse générée pour une raison inconnue. Debug info: {response}"
+            return f"API Google: Aucune réponse générée pour une raison inconnue. Debug info: {response}"
 
     except Exception as e:
         # Catch any other exceptions during the API call
@@ -466,7 +326,7 @@ def _format_time(seconds):
     if not isinstance(seconds, (int, float)) or seconds < 0: return "N/A"
     minutes = int(seconds // 60)
     remaining_seconds = int(seconds % 60)
-    if minutes > 0: return f"{minutes} min {remaining_seconds} sec" # Corrected string formatting
+    if minutes > 0: return f"{minutes} min {remaining_seconds} sec"
     return f"{remaining_seconds} sec"
 
 # -----------------------------------------------------------------------------
@@ -478,7 +338,9 @@ def perform_web_search(query: str, num_results: int = 3) -> str:
         # Use DDGS.text for simple text search (DDGS class)
         # It's best practice to use DDGS as a context manager to ensure proper session closure
         with DDGS() as ddgs:
-            results = ddgs.text(keywords=query, max_results=num_results)
+            # Set region for potentially better results
+            results = ddgs.text(keywords=query, max_results=num_results, region='fr-fr') # Added region
+
             # Convert generator to list for iteration
             results_list = list(results)
 
@@ -495,13 +357,13 @@ def perform_web_search(query: str, num_results: int = 3) -> str:
         return f"Erreur lors de la recherche web: {e}"
 
 # -----------------------------------------------------------------------------
-# Generation Functions (Separated by Task Type)
+# Generation Functions (Simplified as task is fixed to Text)
 # -----------------------------------------------------------------------------
 
 def get_text_response(selected_model_id: str, system_prompt: str, full_chat_history: list[dict]):
     """
     Handles text generation request using the selected text model.
-    Requires the selected model to be of type 'text'.
+    This is the primary generation function in this text-only configuration.
     """
     # Model type compatibility is checked by the caller before calling this function.
     selected_model_info = next((m for m in AVAILABLE_MODELS if m['id'] == selected_model_id), None)
@@ -540,61 +402,60 @@ def get_text_response(selected_model_id: str, system_prompt: str, full_chat_hist
     if st.session_state.enable_web_search and model_provider == 'google':
         last_user_query = full_chat_history[-1]['content'] # Get the user's last actual query
         
-        # Add a temporary message to the chat indicating search is happening
-        # This message will be updated later.
+        # Display "Recherche en cours..." message
         st.session_state.chat_history.append({"role": "assistant", "content": f"*(KolaChatBot recherche sur le web pour '{last_user_query}'...)*", "type": "text"})
-        # No rerun here. The main spinner will now handle the visual update implicitly.
-
-        # Perform the actual web search
-        search_results = perform_web_search(last_user_query)
-        
-        # Create a copy of the history for the API call to avoid modifying session_state directly for previous turns.
-        temp_api_history = []
-        for msg in actual_conversation_history_for_prompt:
-             temp_api_history.append(msg.copy()) # Make sure to copy the dict
-
-        # Prepend search results to the *last user message* in the temp history
-        context_message_content = f"Voici des informations pertinentes du web sur le sujet de la dernière question :\n```\n{search_results}\n```\n\nEn te basant sur ces informations (si pertinentes) et notre conversation, réponds à la question : "
+        st.rerun() # Force a rerun to display this message immediately
 
-        if temp_api_history and temp_api_history[-1]['role'] == 'user' and temp_api_history[-1]['type'] == 'text':
-             temp_api_history[-1]['content'] = context_message_content + temp_api_history[-1]['content']
-        else:
-             # Fallback: add context as a separate user message if last message isn't a simple user text
-             temp_api_history.append({"role": "user", "content": context_message_content, "type": "text"})
+        # This part runs on the *next* rerun
+        try:
+             # Perform the actual web search
+             search_results = perform_web_search(last_user_query)
+             
+             # Create a copy of the history for the API call and inject the search results
+             temp_api_history = []
+             for msg in actual_conversation_history_for_prompt:
+                  temp_api_history.append(msg.copy()) # Make sure to copy the dict
+
+             # Prepend search results to the *last user message* in the temp history
+             context_message_content = f"Voici des informations pertinentes du web sur le sujet de la dernière question :\n```\n{search_results}\n```\n\nEn te basant sur ces informations (si pertinentes) et notre conversation, réponds à la question : "
+
+             if temp_api_history and temp_api_history[-1]['role'] == 'user' and temp_api_history[-1]['type'] == 'text':
+                  temp_api_history[-1]['content'] = context_message_content + temp_api_history[-1]['content']
+             else:
+                  # Fallback: add context as a separate user message if last message isn't a simple user text
+                  temp_api_history.append({"role": "user", "content": context_message_content, "type": "text"})
+
+             # Call the Google API with the modified history
+             response_content = call_google_api(model_id, system_prompt, temp_api_history, params)
+             
+             # Update the search message in chat history to indicate results were used
+             # Find the message we added earlier and update its content
+             if st.session_state.chat_history and st.session_state.chat_history[-1]["content"].startswith("*(KolaChatBot recherche web"):
+                  st.session_state.chat_history[-1]["content"] = f"*(KolaChatBot a terminé la recherche web. Résultats intégrés à la réponse.)*"
+
+
+        except Exception as e:
+             response_content = f"Erreur lors de la recherche web ou de l'intégration des résultats : {e}"
+             # If search failed, update the temporary message to show the error
+             if st.session_state.chat_history and st.session_state.chat_history[-1]["content"].startswith("*(KolaChatBot recherche web"):
+                 st.session_state.chat_history[-1]["content"] = f"*(KolaChatBot a rencontré une erreur lors de la recherche web : {e})*"
 
-        # Call the Google API with the modified history
-        response_content = call_google_api(model_id, system_prompt, temp_api_history, params)
-        
-        # Update the search message in chat history to indicate results were used
-        # We need to find the search message we added earlier.
-        # A simple way is to check the last message's content if it matches our pattern.
-        # This update will be visible after the next rerun when the assistant's main response is displayed.
-        if st.session_state.chat_history[-1]["content"].startswith("*(KolaChatBot recherche web"):
-            st.session_state.chat_history[-1]["content"] = f"*(KolaChatBot a terminé la recherche web pour '{last_user_query}'. Résultats intégrés à la réponse.)*"
 
     else: # No web search or not a Google model
-        if model_provider == 'huggingface':
-            llm_prompt = build_mistral_prompt(system_prompt, actual_conversation_history_for_prompt)
-            if not llm_prompt: return {"role": "assistant", "content": "Erreur lors de la construction du prompt pour Hugging Face (texte).", "type": "text"}
-            response_content = call_hf_inference(model_id, llm_prompt, params, selected_model_info['type'])
-        elif model_provider == 'google':
+        if model_provider == 'google':
             # This path is for Google models WITHOUT web search enabled
             response_content = call_google_api(model_id, system_prompt, actual_conversation_history_for_prompt, params)
         else:
-            response_content = f"Erreur interne: Fournisseur API '{model_provider}' inconnu pour le modèle texte '{model_id}'."
+             # This branch is effectively unreachable with the current AVAILABLE_MODELS list (only Google Text models)
+             response_content = f"Erreur interne: Fournisseur API '{model_provider}' inconnu pour le modèle texte '{model_id}'."
+
 
     return {"role": "assistant", "content": response_content, "type": "text"}
 
 
+# This function is no longer used in this text-only configuration.
 def get_image_response(selected_model_id: str, user_prompt: str):
-    """
-    Handles image generation request using the selected T2I model.
-    This function is now effectively disabled by the app's fixed 'text' task.
-    """
-    # Model type compatibility is checked by the caller before calling this function.
-    # This function is here for structural completeness but won't be executed in this config.
-    st.warning("La tâche 'Image' n'est plus supportée dans cette configuration de l'application.")
-    return {"role": "assistant", "content": "Cette application est configurée pour la génération de texte uniquement. La génération d'images n'est pas disponible.", "type": "text", "prompt": user_prompt}
+     return {"role": "assistant", "content": "La génération d'images n'est pas disponible dans cette version de l'application.", "type": "text", "prompt": user_prompt}
 
 
 # -----------------------------------------------------------------------------
@@ -615,103 +476,96 @@ st.markdown(f"*Tâche actuelle : **{current_task_label}***\n*Modèle : **`{selec
 
 
 # -----------------------------------------------------------------------------
-# Manuel d'utilisation (Update with task separation)
+# Manuel d'utilisation (Update for text-only and RAG)
 # -----------------------------------------------------------------------------
 with st.expander("📖 Manuel d'utilisation de KolaChatBot", expanded=False):
     st.markdown("""
-    Bienvenue sur KolaChatBot - Une application de chat IA multi-modèles ! Voici comment tirer le meilleur parti de notre assistant IA :
+    Bienvenue sur KolaChatBot - Une application de chat IA ! Voici comment tirer le meilleur parti de notre assistant IA :
 
     **1. Comment interagir ?**
     - **La tâche est fixée sur Texte (conversation).**
     - **Entrer votre prompt :** Tapez votre message dans la zone de texte en bas et appuyez sur Entrée.
 
     **2. Paramètres dans la barre latérale (Sidebar) :**
-    La barre latérale adapte ses options au modèle de texte sélectionné.
+    Ajustez les paramètres pour la génération de texte.
 
-    *   **Sélection du Modèle :** Une liste déroulante affichant les modèles disponibles. Choisissez un modèle de texte pour converser.
-        - **Important :** Assurez-vous que les tokens API (`HUGGINGFACEHUB_API_TOKEN` ou `GOOGLE_API_KEY`) nécessaires au fournisseur du modèle sélectionné sont configurés dans votre fichier `.env` ou comme secrets dans votre espace Hugging Face.
-        - Changer de modèle **ne réinitialise pas** automatiquement les paramètres de créativité/longueur. Les paramètres s'appliquent lors d'une nouvelle conversation.
+    *   **Sélection du Modèle :** Choisissez un modèle Google Gemini Flash pour converser.
+        - **Important :** Assurez-vous que la clé API Google (`GOOGLE_API_KEY`) est configurée dans vos secrets.
+        - Changer de modèle **ne réinitialise pas** automatiquement les autres paramètres. Les paramètres actuels seront utilisés lors de la prochaine génération.
     *   **Option "Activer la recherche web" :** Activez cette option pour que l'IA (via les modèles Google Gemini) recherche sur le web et utilise les résultats pour enrichir ses réponses.
-    *   **Paramètres spécifiques au Modèle :** Les options de paramètres affichées changent en fonction du modèle sélectionné (uniquement des modèles texte ici).
-        *   **Pour un modèle "Texte" :** Message Système / Personnalité, Max New Tokens (longueur max réponse), Temperature (créativité), Top-P (sampling).
-        - **Attention :** Modifier les paramètres spécifiques et cliquer sur "Appliquer Paramètres & Nouvelle Conversation" **efface** également l'historique/conversation.
+    *   **Paramètres de Génération :** Ajustez la longueur maximale de la réponse, la température (créativité), et le Top-P (sampling).
+    *   **Message Système / Personnalité :** Définissez le rôle ou le style que l'IA de texte doit adopter.
+    *   **Message de Bienvenue de l'IA :** Personnalisez le message initial.
     *   **Sélection des Avatars.**
-    *   **Gestion de la Conversation :** Boutons pour appliquer les paramètres actuels (et démarrer une nouvelle conversation) ou simplement effacer l'historique actuel.
-    *   **Exporter la Conversation :** Téléchargez l'historique. Notez que les images générées ne sont pas incluses dans les exports TXT et Markdown, seul le prompt l'est.
+    *   **Gestion de la Conversation :** Utilisez les boutons pour appliquer les paramètres actuels (et démarrer une nouvelle conversation) ou simplement effacer l'historique actuel.
+    *   **Exporter la Conversation :** Téléchargez l'historique.
 
     **3. Limitations :**
-    - **L'application est configurée uniquement pour la tâche de génération de texte.** Si vous sélectionnez un modèle d'image (non recommandé dans cette configuration), toute tentative de génération entraînera une erreur de compatibilité affichée dans le chat. Vous devez utiliser un modèle de texte.
-    - La fonction "Recherche Web" est actuellement implémentée uniquement pour les modèles Google Gemini et peut entraîner des délais supplémentaires.
+    - **L'application est configurée uniquement pour la tâche de génération de texte.** Seuls les modèles Google Gemini Flash sont disponibles. Tenter d'utiliser un autre type de modèle entraînerait une erreur.
+    - La fonction "Recherche Web" est actuellement implémentée uniquement pour les modèles Google Gemini et peut entraîner des délais supplémentaires. Les résultats de recherche web s'affichent temporairement dans le chat avant la réponse de l'IA.
     - Notez que l'application de votre **Message Système / Personnalité** aux modèles Google dépend de la prise en charge de la fonctionnalité `system_instruction` par la version de la bibliothèque Google Generative AI et le modèle spécifique utilisé. Si vous obtenez des erreurs (`unexpected keyword argument 'system_instruction'`), le message système sera ignoré pour ces modèles.
-    - Cette application ne stocke pas les images de manière permanente. Elles sont présentes dans l'historique de session tant que l'application tourne.
-    - Les modèles gratuits sur l'API Hugging Face peuvent avoir des files d'attente ou des limites d'utilisation.
+    - Cette application ne stocke pas les données de manière permanente. L'historique est présent dans la session tant que l'application tourne.
 
     Amusez-vous bien avec KolaChatBot !
     """)
 # -----------------------------------------------------------------------------
-# Sidebar settings (with task, model, and param separation)
+# Sidebar settings
 # -----------------------------------------------------------------------------
 with st.sidebar:
     st.header("🛠️ Configuration de KolaChatBot")
 
-    # Removed the radio button for task selection. Task is now fixed to 'text'.
-    st.subheader("🎯 Tâche IA : Texte (fixée)") # Indicate that task is fixed
-    # The st.session_state.selected_task is already initialized to 'text' and not changed here.
+    # Task is fixed to 'text'
+    st.subheader("🎯 Tâche IA : Texte (fixée)")
 
     st.subheader("🧠 Sélection du Modèle")
     all_available_models = AVAILABLE_MODELS
 
-    if not all_available_models: # Check if ANY models are defined
+    if not all_available_models:
         st.warning("Aucun modèle disponible défini dans la liste AVAILABLE_MODELS.")
-        st.session_state.selected_model_id = None # Ensure no model is selected
+        st.session_state.selected_model_id = None
     else:
         model_options = {model['id']: model['name'] for model in all_available_models}
 
-        # Determine the index of the currently selected model ID within the list of ALL model options
-        # If the current ID is not in the list, default to the first option
         current_model_index = 0
         if st.session_state.selected_model_id in model_options:
             current_model_index = list(model_options.keys()).index(st.session_state.selected_model_id)
-        elif all_available_models: # If no match, default to first available
-            st.session_state.selected_model_id = all_available_models[0]['id']
-            current_model_index = 0
+        elif all_available_models:
+             default_model_from_list = next((m for m in AVAILABLE_MODELS), None)
+             if default_model_from_list:
+                 st.session_state.selected_model_id = default_model_from_list['id']
+                 current_model_index = 0
+             else:
+                 st.session_state.selected_model_id = None
+
 
-        # Store the value of selected_model_id *before* the selectbox potentially changes it
         st.session_state._prev_model_id_before_selectbox = st.session_state.selected_model_id
-        # The selectbox's value will update st.session_state.selected_model_id because of the 'key'
         selected_model_id_from_selectbox_value = st.selectbox(
             "Choisir le modèle :",
             options=list(model_options.keys()),
             format_func=lambda x: model_options[x],
             index=current_model_index,
-            key="selected_model_id", # Directly link to session state variable
-            help="Sélectionnez un modèle disponible. Pour cette application, seul un modèle de texte sera fonctionnel."
+            key="selected_model_id",
+            help="Sélectionnez un modèle disponible (uniquement modèles texte pris en charge dans cette version)."
         )
-        # st.session_state.selected_model_id is now updated automatically by the key="selected_model_id"
 
 
     # --- Model Change Detection (without auto-resetting params) ---
-    # We still need to detect if the model changed to potentially reset history
-    # and to update which parameters are displayed in the expander.
     model_id_changed_this_run = st.session_state.selected_model_id != st.session_state.get('_prev_model_id_before_selectbox')
-    
-    # Task is fixed, so task_changed_this_run is always False
-    task_changed_this_run = False # Explicitly set to False as radio button is removed.
 
     # If model changed (and not triggered by an explicit button reset), reset history
-    # Parameters are no longer auto-reset here. They only reset on explicit button click.
     if model_id_changed_this_run and not st.session_state.get('_reset_triggered', False):
         st.session_state.chat_history = [{"role": "assistant", "content": st.session_state.starter_message, "type": "text"}]
         st.info(f"⚠️ Modèle changé. La conversation a été réinitialisée. Les paramètres restent les mêmes jusqu'à application explicite.")
-        # Do not set _reset_triggered here, as it's not a full settings reset.
-        st.rerun() # Rerun to refresh UI after history reset.
+        # Do not set _reset_triggered here
+        st.rerun()
+
 
-    # Check required API Key for the selected model (This check runs after a potential rerun)
-    if st.session_state.selected_model_id: # Only check if a model ID is actually selected
+    # Check required API Key for the selected model
+    if st.session_state.selected_model_id:
         current_model_info_check = next((m for m in AVAILABLE_MODELS if m['id'] == st.session_state.selected_model_id), None)
         if current_model_info_check:
             current_model_provider = current_model_info_check['provider']
-            if current_model_provider == 'huggingface':
+            if current_model_provider == 'huggingface': # Should not happen with current models
                 if not HUGGINGFACEHUB_API_TOKEN:
                     st.warning("❌ Le token Hugging Face est manquant (`HUGGINGFACEHUB_API_TOKEN`). Les modèles Hugging Face ne fonctionneront pas.")
             elif current_model_provider == 'google':
@@ -721,20 +575,17 @@ with st.sidebar:
 
     # --- Dynamic Parameter Settings based on the SELECTED MODEL's TYPE ---
     st.subheader("⚙️ Paramètres")
-    # Get the info for the *currently selected* model to determine which parameters to show
     current_selected_model_info = next((m for m in AVAILABLE_MODELS if m['id'] == st.session_state.selected_model_id), None)
 
     if st.session_state.selected_model_id and current_selected_model_info:
-        # Use expander title to indicate which model's params are shown
-        expander_title = f"Ajuster Paramètres : {current_selected_model_info['type'].capitalize()} ({current_selected_model_info['name']})"
+        expander_title = f"Ajuster Paramètres : {current_selected_model_info['name']}" # Simplified title
         with st.expander(expander_title, expanded=True):
+            # Since only text models are available, only display text parameters
             if current_selected_model_info['type'] == 'text':
-                 # Link input widgets directly to session state parameters
-                 # Max New Tokens: Increased max_value to 8192
                  st.session_state.max_response_length = st.number_input(
                      "Max New Tokens (longueur max réponse) :",
-                     min_value=20, max_value=8192,
-                     value=st.session_state.max_response_length, # No None check here, as it's initialized on startup
+                     min_value=20, max_value=8192, # Increased max_value
+                     value=st.session_state.max_response_length,
                      step=10,
                      key="max_new_tokens_input",
                      help="Longueur maximale de la réponse de l'IA (en jetons ou tokens).",
@@ -742,7 +593,7 @@ with st.sidebar:
                  st.session_state.temperature = st.slider(
                      "Temperature (créativité) :",
                      min_value=0.0, max_value=2.0,
-                     value=st.session_state.temperature, # No None check here
+                     value=st.session_state.temperature,
                      step=0.01,
                      key="temperature_input",
                      help="Contrôle le caractère aléatoire des réponses. Plus élevé = plus créatif/imprévisible.",
@@ -750,19 +601,18 @@ with st.sidebar:
                  st.session_state.top_p = st.slider(
                      "Top-P (sampling) :",
                      min_value=0.01, max_value=1.0,
-                     value=st.session_state.top_p, # No None check here
+                     value=st.session_state.top_p,
                      step=0.01,
                      key="top_p_input",
                      help="Contrôle la diversité en limitant les options de tokens. Plus bas = moins diversifié. 1.0 = désactivé.",
                  )
 
-                 # Handle System and Starter messages here for text task
                  st.session_state.system_message = st.text_area(
                      "Message Système / Personnalité :",
                      value=st.session_state.system_message,
                      height=100,
                      key="system_message_input",
-                     help="Décrivez le rôle ou le style que l'IA de texte doit adopter. Sa capacité à suivre cette consigne dépend du modèle. Notez que cette consigne peut être ignorée par certains modèles ou fournisseurs si la fonctionnalité dédiée n'est pas supportée (voir Limitations).",
+                     help="Décrivez le rôle ou le style que l'IA de texte doit adopter. Notez que cette consigne peut être ignorée par certains modèles/versions API (voir Limitations).",
                  )
                  st.session_state.starter_message = st.text_area(
                      "Message de Bienvenue de l'IA :",
@@ -771,85 +621,44 @@ with st.sidebar:
                      key="starter_message_input",
                      help="Le premier message que l'IA affichera au début d'une nouvelle conversation textuelle ou après un reset.",
                  )
-                 # Web Search Checkbox - only displayed for text models
-                 st.session_state.enable_web_search = st.checkbox(
-                     "Activer la recherche web (pour les modèles Google)",
-                     value=st.session_state.enable_web_search,
-                     key="web_search_checkbox",
-                     help="Si coché, les modèles Google Gemini effectueront une recherche DuckDuckGo et utiliseront les résultats pour répondre à votre prompt."
-                 )
-
-
-            elif current_selected_model_info['type'] == 't2i':
-                 # Link input widgets directly to session state T2I parameters
-                 # Display parameters for T2I model even if task is fixed to Text
-                 st.info("Note: Les paramètres d'image sont affichés car ce modèle est de type 'Image'. Cependant, la tâche de l'application est fixée sur 'Texte'. Les prompts images ne généreront pas d'images mais des erreurs de compatibilité.")
-                 st.session_state.num_inference_steps = st.number_input(
-                     "Nombre d'étapes d'inférence :",
-                     min_value=1, max_value=200,
-                     value=st.session_state.num_inference_steps, step=5,
-                     key="num_inference_steps_input",
-                     help="Nombre d'étapes dans le processus de diffusion. Plus élevé = potentiellement meilleure qualité mais plus lent."
-                 )
-                 st.session_state.guidance_scale = st.number_input(
-                     "Échelle de guidage (CFG) :",
-                     min_value=0.0, max_value=20.0,
-                     value=st.session_state.guidance_scale, step=0.5,
-                     key="guidance_scale_input",
-                     help="Dans quelle mesure l'IA doit suivre le prompt. Plus élevé = plus fidèle au prompt mais potentiellement moins créatif."
-                 )
-                 st.session_state.image_height = st.number_input(
-                     "Hauteur de l'image :",
-                     min_value=128, max_value=1024,
-                     value=st.session_state.image_height, step=64,
-                     key="image_height_input",
-                     help="Hauteur en pixels de l'image générée."
-                 )
-                 st.session_state.image_width = st.number_input(
-                     "Largeur de l'image :",
-                     min_value=128, max_value=1024,
-                     value=st.session_state.image_width, step=64,
-                     key="image_width_input",
-                     help="Largeur en pixels de l'image générée."
-                 )
-                 st.session_state.negative_prompt = st.text_area(
-                     "Prompt Négatif :",
-                     value=st.session_state.negative_prompt,
-                     height=100,
-                     key="negative_prompt_input",
-                     help="Ce que vous NE voulez PAS voir dans l'image."
-                 )
-
-        # Add a message if model type is not explicitly handled for parameters
-        if current_selected_model_info and current_selected_model_info['type'] not in ['text', 't2i']:
+                 # Web Search Checkbox - only displayed for Google models
+                 if current_selected_model_info['provider'] == 'google':
+                     st.session_state.enable_web_search = st.checkbox(
+                         "Activer la recherche web (pour les modèles Google)",
+                         value=st.session_state.enable_web_search,
+                         key="web_search_checkbox",
+                         help="Si coché, les modèles Google Gemini effectueront une recherche DuckDuckGo et utiliseront les résultats pour répondre à votre prompt."
+                     )
+                 else: # If a non-Google model were added back
+                      # Ensure checkbox state is not changed and it's disabled
+                      # Use a unique key based on model_id to prevent state interference if model changes
+                      st.session_state.enable_web_search = st.checkbox(
+                         "Activer la recherche web (pour les modèles Google)",
+                         value=False, # Always False if not Google
+                         key=f"web_search_checkbox_{current_selected_model_info.get('id', 'nongoogle')}", # Unique key
+                         disabled=True,
+                         help="La recherche web n'est disponible que pour les modèles Google Gemini.",
+                     )
+
+            elif current_selected_model_info['type'] == 't2i': # This branch should not be hit
+                 st.info("Note: Ce modèle est de type 'Image', mais l'application ne supporte que la tâche 'Texte'.")
+
+        if current_selected_model_info and current_selected_model_info['type'] not in ['text', 't2i']: # Should not be hit
              st.info(f"Type de modèle sélectionné ('{current_selected_model_info['type']}') inconnu ou non pris en charge pour l'affichage des paramètres.")
 
-    else: # This ELSE correctly pairs with the outer 'if st.session_state.selected_model_id...'
+    else:
          st.info("Aucun modèle sélectionné, les paramètres ne sont pas disponibles.")
 
 
     # Flag used to detect if 'Appliquer Paramètres' or 'Effacer' was clicked
     # and prevent regeneration on the immediate rerun
-    # Reset this flag at the beginning of the sidebar block after potential check
-    # (already done above, but repeating for clarity if this block were moved)
-    # reset_just_triggered = st.session_state.get('_reset_triggered', False)
-    # if reset_just_triggered:
-    #     st.session_state._reset_triggered = False # Clear the flag
-
-
-    st.subheader("👤 Interface Utilisateur")
-    with st.expander("Choisir les Avatars Cyberpunk", expanded=False):
-        st.markdown("*Sélection des avatars personnalisés :*")
-        col1_avatar, col2_avatar = st.columns(2)
-        with col1_avatar:
-            st.session_state.avatars["assistant"] = st.selectbox("Avatar IA", options=["🤖", "🎨", "✨", "💡", "🌟", "👩🏽‍⚕️", "👨🏿‍🎓", "⚙️"], index=0, key="avatar_ia_select")
-        with col2_avatar:
-            st.session_state.avatars["user"] = st.selectbox("Avatar Utilisateur", options=["👤", "👩‍💻", "👨‍🎓", "❓", "💡", "🧑‍🔧", "👩🏽‍🔬", "🕵🏽", "🧑‍🚀"], index=0, key="avatar_user_select")
+    if st.session_state.get('_reset_triggered', False):
+         st.session_state._reset_triggered = False
+
 
     st.subheader("🔄 Gestion de la Conversation")
     # Reset button that applies *all* parameters (system/starter/model) and starts new conversation
-    # The help message is adapted since task is fixed.
-    if st.button("♻️ Appliquer Paramètres & Nouvelle Conversation", type="primary", help=f"Applique les paramètres actuels et démarre une nouvelle conversation texte en effaçant l'historique."):
+    if st.button("♻️ Appliquer Paramètres & Nouvelle Conversation", type="primary", help="Applique les paramètres actuels et démarre une nouvelle conversation texte en effaçant l'historique."):
         # Parameters are already updated in session state via key linking
         # Reset history.
         st.session_state.chat_history = [{"role": "assistant", "content": st.session_state.starter_message, "type": "text"}]
@@ -858,7 +667,7 @@ with st.sidebar:
         st.rerun() # Rerun immediately to refresh UI
 
     # Clear history button - simpler, just history
-    if st.button("🗑️ Effacer la Conversation Actuelle", help=f"Efface l'historique de conversation mais conserve les paramètres actuels."):
+    if st.button("🗑️ Effacer la Conversation Actuelle", help="Efface l'historique de conversation mais conserve les paramètres actuels."):
         # Reset history.
         st.session_state.chat_history = [{"role": "assistant", "content": st.session_state.starter_message, "type": "text"}]
         st.info("Conversation actuelle effacée.")
@@ -919,61 +728,58 @@ with st.sidebar:
 chat_interface_container = st.container(height=600, border=True)
 
 with chat_interface_container:
+    # Embed a div with a specific ID for the chat history messages
+    st.markdown("<div id='chat_history_container_scroll_area'>", unsafe_allow_html=True)
+
     # Display existing messages from chat_history.
-    # System messages are never displayed. Messages can be text or image.
     for message in st.session_state.chat_history:
-        if message["role"] == "system":
-            continue # Skip system messages
+        if message["role"] == "system": continue
 
-        avatar_type = st.session_state.avatars.get(message["role"], "❓") # Default avatar
+        avatar_type = st.session_state.avatars.get(message["role"], "❓")
 
         with st.chat_message(message["role"], avatar=avatar_type):
-            message_type = message.get("type", "text") # Default to text type
+            message_type = message.get("type", "text")
             if message_type == "text":
-                st.markdown(message.get("content", "")) # Display text content
-            elif message_type == "t2i_prompt": # User prompt for T2I task
-                # Display user's prompt for an image generation request
+                st.markdown(message.get("content", ""))
+            elif message_type == "t2i_prompt": # Should not happen with current config
                 st.markdown(f"Prompt image : *{message.get('content', 'Prompt vide')}*")
-            elif message_type == "t2i" and ("image_data" in message or "content" in message): # AI image response (success or error)
-                # Display generated image or error message
-                prompt_text = message.get('prompt', 'Pas de prompt enregistré')
-                error_text = message.get('content', '') # Potential error message content
-
-                st.markdown(f"Prompt: *{prompt_text}*") # Always display the prompt for context
-                if "image_data" in message:
-                    try:
-                        image = Image.open(BytesIO(message["image_data"]))
-                        st.image(image, caption="Image générée")
-                    except Exception as e:
-                        st.error(f"Erreur lors de l'affichage de l'image : {e}")
-                elif error_text: # Display error message if image data is not present but content is
-                     st.error(f"Échec de la génération d'image: {error_text}")
-                else: # Fallback for unexpected t2i message format
-                     st.warning("Réponse image de format inattendu.")
-
-
-            # Add other message types if needed in the future (e.g., multimodal)
+            elif message_type == "t2i" and ("image_data" in message or "content" in message): # Should not happen with current config
+                 st.markdown(f"Prompt: *{message.get('prompt', 'Pas de prompt enregistré')}*")
+                 if "image_data" in message:
+                      try: st.image(Image.open(BytesIO(message["image_data"])), caption="Image générée")
+                      except Exception as e: st.error(f"Erreur affichage image : {e}")
+                 elif message.get('content'): st.error(f"Échec génération image: {message.get('content')}")
+                 else: st.warning("Réponse image format inattendu.")
+
+
+    # Close the div for the scroll area
+    st.markdown("</div>", unsafe_allow_html=True)
+
+    # JavaScript to scroll to the bottom
+    # Needs to be inside the container's 'with' block or just below it.
+    # Running it after all messages are rendered ensures it scrolls to the *new* last message.
+    st.markdown(
+        """
+        <script>
+        var chatHistory = document.getElementById('chat_history_container_scroll_area');
+        if (chatHistory) {
+            chatHistory.scrollTop = chatHistory.scrollHeight;
+        }
+        </script>
+        """,
+        unsafe_allow_html=True,
+    )
+
 
 # Area for the chat input box
 input_container = st.container()
 with input_container:
-    # Check if a model is selected before showing the input box and enabling it
     if st.session_state.selected_model_id is not None:
-        # Get the type of the currently selected model to refine the placeholder text
         current_selected_model_info = next((m for m in AVAILABLE_MODELS if m['id'] == st.session_state.selected_model_id), None)
-        if current_selected_model_info and current_selected_model_info['type'] == 'text':
-            placeholder_text = f"Entrez votre message pour la conversation texte..."
-        elif current_selected_model_info and current_selected_model_info['type'] == 't2i':
-             # Even though task is fixed to text, if a T2I model is selected, its param controls still show.
-             # Placeholder reflects the *model type* but the app's task is text.
-             placeholder_text = f"Prompt pour un modèle d'image (mais l'application est en mode texte)..."
-        else: # Fallback if model type is unknown or model info missing
-             placeholder_text = f"Entrez votre prompt pour la tâche Texte..."
-
+        placeholder_text = f"Entrez votre message pour la conversation texte..." # Fixed placeholder text as task is text
         user_input = st.chat_input(placeholder=placeholder_text, disabled=False)
     else:
          user_input = st.chat_input(placeholder=f"Veuillez configurer un modèle disponible pour démarrer...", disabled=True)
-         # Display a message prompting the user if no model is selected
          st.info(f"Veuillez sélectionner un modèle disponible dans la barre latérale pour commencer. Il n'y a actuellement aucun modèle configuré ou sélectionné.")
 
 
@@ -982,11 +788,7 @@ with input_container:
 # AND a model is selected AND the reset flag is not set (from buttons)
 if user_input and st.session_state.selected_model_id and not st.session_state.get('_reset_triggered', False):
     # 1. Append the user's message to the chat history
-    user_message_entry = {"role": "user", "content": user_input}
-
-    # The user's input type is now always 'text' because the task is fixed to 'text'.
-    user_message_entry["type"] = "text" # Input is always considered text now
-
+    user_message_entry = {"role": "user", "content": user_input, "type": "text"} # Always text input now
     st.session_state.chat_history.append(user_message_entry)
 
     # --- Trigger a rerun to immediately show the user message ---
@@ -1004,10 +806,9 @@ if st.session_state.chat_history and st.session_state.chat_history[-1]["role"] =
     selected_model_info = next((m for m in AVAILABLE_MODELS if m['id'] == st.session_state.selected_model_id), None)
 
     if not selected_model_info:
-        # Display error in chat if model not found (should ideally be caught by sidebar logic)
-        error_message = {"role": "assistant", "content": f"Erreur: Modèle sélectionné '{st.session_state.selected_model_id}' introuvable dans la liste AVAILABLE_MODELS.", "type": "text"}
+        error_message = {"role": "assistant", "content": f"Erreur: Modèle sélectionné '{st.session_state.selected_model_id}' introuvable.", "type": "text"}
         st.session_state.chat_history.append(error_message)
-        st.rerun() # Rerun to display error
+        st.rerun()
     else:
         current_model_display_name = selected_model_info['name']
         current_model_type = selected_model_info['type'] # Get type from the *selected model* info
@@ -1016,58 +817,55 @@ if st.session_state.chat_history and st.session_state.chat_history[-1]["role"] =
         last_user_message_content = last_user_message.get("content", "")
 
 
-        # === Task/Model/Input Type Compatibility Check (Simplified as task is fixed to 'text') ===
-        is_compatible = False
-        error_reason = ""
-
-        # Since selected_task is always 'text' now, we only need to check model type and input type
-        if current_model_type == 'text':
-            if last_user_message_type == 'text':
-                is_compatible = True
-            else: # This path should not be hit if input type is always 'text' for user_message_entry
-                error_reason = f"Votre dernier message (Type: '{last_user_message_type}') n'est pas du texte, requis pour la tâche 'Texte'."
-        # If current_model_type is 't2i' (as per new model list, SDXL is gone, so this won't be hit unless you manually add it back)
-        # else: # current_model_type is 't2i' or other
-        #     error_reason = f"Le modèle sélectionné ('{current_model_display_name}' - Type: '{current_model_type}') n'est pas un modèle de texte, requis pour la tâche 'Texte'."
-        # Since we removed t2i models from AVAILABLE_MODELS, this 'else' is unreachable for standard flow.
-        # But for safety, we can keep the logic if you were to add them back later.
-        # However, for this version, the only way to get here with an incompatible model is if AVAILABLE_MODELS is messed up.
-        # The line above already handles it if current_model_type is NOT 'text'.
-        # Let's simplify the error check logic slightly, as there are only text models now.
-        if not (current_model_type == 'text' and last_user_message_type == 'text'):
-            error_message_content = f"Erreur de compatibilité : La tâche de l'application est 'Texte', mais le modèle sélectionné ('{current_model_display_name}' - Type: '{current_model_type}') ou votre dernier message (Type: '{last_user_message_type}') n'est pas compatible.\nVeuillez sélectionner un modèle de texte pour continuer la conversation."
+        # === Task/Model Compatibility Check (Simplified as task is fixed to 'text') ===
+        # Check if the selected model is of type 'text'
+        if current_model_type != 'text':
+            # If the model type is not text, display compatibility error
+            error_message_content = f"Erreur de compatibilité : L'application ne supporte que les modèles de texte, mais le modèle sélectionné ('{current_model_display_name}' - Type: '{current_model_type}') n'est pas un modèle de texte.\nVeuillez sélectionner un modèle de texte pour continuer la conversation."
             error_message_entry = {"role": "assistant", "content": error_message_content, "type": "text"}
             st.session_state.chat_history.append(error_message_entry)
             st.rerun()
-        else: # All checks passed, proceed with generation
+        else:
+            # === Task and Model are Compatible (Text task, Text model) - Proceed with Generation ===
             assistant_response_entry = None
 
             with chat_interface_container: # Place spinner within the chat container where response will appear
-                assistant_avatar = st.session_state.avatars.get("assistant", "❓") # Get assistant avatar
+                assistant_avatar = st.session_state.avatars.get("assistant", "❓")
                 with st.chat_message("assistant", avatar=assistant_avatar):
+                    # The spinner message is shown here, wrapping the API call
                     with st.spinner(f"KolaChatBot utilise {current_model_display_name} pour générer... 🤔"):
-
-                        # Since selected_task is always 'text' and compatibility is checked, we only call get_text_response
+                        # Call get_text_response (which now handles RAG internally for Google)
                         assistant_response_entry = get_text_response(
                             selected_model_id=st.session_state.selected_model_id,
                             system_prompt=st.session_state.system_message,
                             full_chat_history=st.session_state.chat_history # Pass full history
                         )
-                         # Display the content from the response entry object returned by get_text_response
-                        if assistant_response_entry and assistant_response_entry.get("type") == "text":
-                             st.markdown(assistant_response_entry.get("content", "Erreur: Réponse texte vide."))
-                        elif assistant_response_entry: # Handle errors returned as text from the generation function
-                             st.error(f"Erreur lors de la génération: {assistant_response_entry.get('content', 'Raison inconnue.')}")
-                        else: # Handle None response from get_text_response
-                             st.error("La fonction de génération de texte n'a pas renvoyé de réponse valide.")
-
-
-                    # --- Append the generated response entry to chat history ---
-                    # Ensure we have received a valid response entry object before appending
-                    if assistant_response_entry is not None:
-                        st.session_state.chat_history.append(assistant_response_entry)
-                        # No need for another st.rerun() after appending and displaying,
-                        # the UI is already updated.
+                    # Display the content from the response entry object returned by get_text_response
+                    # This happens *after* the spinner block
+                    if assistant_response_entry and assistant_response_entry.get("type") == "text":
+                        st.markdown(assistant_response_entry.get("content", "Erreur: Réponse texte vide."))
+                    elif assistant_response_entry: # Handle errors returned as text from the generation function
+                        st.error(f"Erreur lors de la génération: {assistant_response_entry.get('content', 'Raison inconnue.')}")
+                    else: # Handle None response from get_text_response
+                        st.error("La fonction de génération de texte n'a pas renvoyé de réponse valide.")
+
+
+            # --- Append the generated response entry to chat history ---
+            if assistant_response_entry is not None:
+                # Check if the last message added was the search message placeholder.
+                # If so, replace it with the actual response. Otherwise, just append.
+                if st.session_state.chat_history[-1]["role"] == "assistant" and \
+                   st.session_state.chat_history[-1]["content"].startswith("*(KolaChatBot recherche web"):
+                     # Remove the temporary search message
+                     st.session_state.chat_history.pop()
+                     # Append the actual response
+                     st.session_state.chat_history.append(assistant_response_entry)
+                else:
+                     # Just append the response if no search message was pending
+                     st.session_state.chat_history.append(assistant_response_entry)
+
+                # No need for another st.rerun() here, the UI is already updated by the first rerun.
+
 
 # --- Clear reset flag at the very end of the script if it was set ---
 # This ensures the flag is only True for one full rerun cycle after a button click