add way to split xlsx for storage

Signed-off-by: Laurent Paoletti <lp@providenz.fr>

.github/workflows/conversations.yml

@@ -200,3 +200,22 @@ jobs:
 
       - name: Run tests
         run: ~/.local/bin/pytest -n 2
+
+  security-trivy-critical:
+    permissions:
+      contents: read
+      security-events: write
+    runs-on: ubuntu-latest
+    steps:
+      - name: Run Trivy analysis for critical vulnerabilities
+        # We use main branch while we might still iterate on the action
+        uses: numerique-gouv/action-trivy-cache/security-trivy-critical@main
+
+  security-trivy:
+    permissions:
+      contents: read
+    runs-on: ubuntu-latest
+    steps:
+      - name: Run Trivy analysis for vulnerabilities
+        # We use main branch while we might still iterate on the action
+        uses: numerique-gouv/action-trivy-cache/security-trivy@main

CHANGELOG.md

@@ -8,6 +8,42 @@ and this project adheres to
 
 ## [Unreleased]
 
+### Changed
+
+- 📦️(front) update react
+
+### Fixed
+
+- 🐛(e2e) fix test-e2e-chromium
+- 🐛(back) fix system prompt compatibility with self-hosted models #200
+- ⚰️(back) remove dead code and unused files
+
+## [0.0.10] - 2025-12-15
+
+### Added
+
+- ✨(front) add retry button
+
+### Fixed
+
+- 🐛(front) fix long user messages
+- 🐛(front) fix "Maximum update depth exceeded" error in Chat component
+- 🐛(front) fix parsing documents display
+- 🐛(front) fix opacity input in error
+- 🐛(front) resolve React hydration errors
+- 🚑️(user) allow longer short names #182
+
+## [0.0.9] - 2025-11-17
+
+### Added
+
+- ✨(front) add code copy button
+- ✨(RAG) add generic collection RAG tools #159
+
+### Fixed
+
+- 🔊(langfuse) enable tracing with redacted content #162
+
 ## [0.0.8] - 2025-11-10
 
 ### Fixed
@@ -22,28 +58,24 @@ and this project adheres to
 
 - 🔥(posthog) remove posthog middleware for async mode fix #146
 
-
 ## [0.0.7] - 2025-10-28
 
 ### Fixed
 
 - 🚑️(posthog) fix the posthog middleware for async mode #133
 
-
 ## [0.0.6] - 2025-10-28
 
 ### Fixed
 
 - 🚑️(stats) fix tracking id in upload event #130
 
-
 ## [0.0.5] - 2025-10-27
 
 ### Fixed
 
 - 🚑️(drag-drop) fix the rejection display on Safari #127
 
-
 ## [0.0.4] - 2025-10-27
 
 ### Added
@@ -60,14 +92,12 @@ and this project adheres to
 - 🐛(front) fix mobile source
 - 🐛(attachments) reject the whole drag&drop if unsupported formats #123
 
-
 ## [0.0.3] - 2025-10-21
 
 ### Fixed
 
 - 🚑️(web-search) fix missing argument in RAG backend #116
 
-
 ## [0.0.2] - 2025-10-21
 
 ### Added
@@ -77,6 +107,7 @@ and this project adheres to
 - 📈(posthog) add `sub` field to tracking #95
 
 ### Changed
+
 - 🔧(front) change links feedback tchap + settings popup
 - 🐛(front) code activation fix session end #93
 - 💬(wording) error page wording #102
@@ -84,7 +115,6 @@ and this project adheres to
 - 🐛(activation-codes) create contact in brevo before add to list #108
 - ⚗️(summarization) add system prompt to handle tool #112
 
-
 ## [0.0.1] - 2025-10-19
 
 ### Changed
@@ -107,7 +137,7 @@ and this project adheres to
 - 🎨(front) change list attachment in chat
 - 🎨(front) move emplacement for attachment
 - 🎨(ui) retour ui sources files
-- ✨(ui) fix retour global ui 
+- ✨(ui) fix retour global ui
 - 🐛(fix) broken staging css
 - 🎨(alpha) adjustment for alpha version
 - ✨(ui) delete flex message
@@ -142,7 +172,9 @@ and this project adheres to
 - 💄(chat) add code highlighting for LLM responses #67
 
 
-[unreleased]: https://github.com/suitenumerique/conversations/compare/v0.0.8...main
+[unreleased]: https://github.com/suitenumerique/conversations/compare/v0.0.10...main
+[0.0.10]: https://github.com/suitenumerique/conversations/releases/v0.0.10
+[0.0.9]: https://github.com/suitenumerique/conversations/releases/v0.0.9
 [0.0.8]: https://github.com/suitenumerique/conversations/releases/v0.0.8
 [0.0.7]: https://github.com/suitenumerique/conversations/releases/v0.0.7
 [0.0.6]: https://github.com/suitenumerique/conversations/releases/v0.0.6

Makefile

@@ -126,7 +126,7 @@ build-frontend: ## build the frontend container
 build-e2e: cache ?=
 build-e2e: ## build the e2e container
 	@$(MAKE) build-backend cache=$(cache)
-	@$(COMPOSE_E2E) build frontend $(cache)
+	@$(COMPOSE_E2E) build frontend openmockllm-mistral $(cache)
 .PHONY: build-e2e
 
 down: ## stop and remove containers, networks, images, and volumes
@@ -158,7 +158,7 @@ create-compose-with-models: ## override the docker-compose file with models
 run-e2e: ## start the e2e server
 run-e2e:
 	@$(MAKE) run-backend
-	@$(COMPOSE_E2E) up --force-recreate -d frontend
+	@$(COMPOSE_E2E) up --force-recreate -d frontend openmockllm-mistral
 .PHONY: run-e2e
 
 status: ## an alias for "docker compose ps"

compose-e2e.yml

@@ -11,3 +11,22 @@ services:
     image: conversations:frontend-production
     ports:
       - "3000:3000"
+
+  openmockllm-mistral:
+    user: "${DOCKER_USER:-1000}"
+    build:
+      context: .
+      dockerfile: ./src/OpenMockLLM/Dockerfile
+    image: conversations:openmockllm-mistral
+    command:
+      - openmockllm
+      - --host
+      - "0.0.0.0"
+      - --port
+      - "8000"
+      - --backend
+      - mistral
+      - --model-name
+      - mistral-mock
+    ports:
+      - "8900:8000"

env.d/development/common.e2e.dist

@@ -2,6 +2,9 @@
 BURST_THROTTLE_RATES="200/minute"
 SUSTAINED_THROTTLE_RATES="200/hour"
 
+# LLM
+LLM_CONFIGURATION_FILE_PATH = /app/conversations/configuration/llm/default.e2e.json
+
 # Features
 FEATURE_FLAG_WEB_SEARCH=ENABLED
 FEATURE_FLAG_DOCUMENT_UPLOAD=ENABLED

package.json

@@ -1,6 +0,0 @@
-{
-  "dependencies": {
-    "@ai-sdk/react": "^1.2.12",
-    "@ai-sdk/ui-utils": "^1.2.11"
-  }
-}

src/OpenMockLLM/Dockerfile

@@ -0,0 +1,19 @@
+FROM python:3.13.3-alpine
+
+# Upgrade pip to its latest release to speed up dependencies installation
+RUN python -m pip install --upgrade pip setuptools lorem-text
+
+# Upgrade system packages to install security updates
+RUN apk update && \
+  apk upgrade
+
+RUN apk add --no-cache git
+
+# Install the package
+RUN pip install git+https://github.com/etalab-ia/openmockllm.git
+
+# Expose the default port
+EXPOSE 8000
+
+# Set default command
+CMD ["openmockllm", "--host", "0.0.0.0", "--port", "8000"]

src/OpenMockLLM/README.md

@@ -0,0 +1,19 @@
+[OpenMockLLM](https://github.com/etalab-ia/OpenMockLLM) is a FastAPI-based mock LLM API server that simulates 
+several Large Language Model API providers.
+
+This is a simple docker image to run the server for testing and development purposes (E2E tests mainly).
+
+It's a bit overkill to have a dedicated image for that, but it allows simple E2E stack with docker-compose since
+our code is also run in Docker containers.
+
+## Build and Run manually
+
+```bash
+docker build -t openmockllm .
+docker run -p 8000:8000 openmockllm
+```
+
+## Next steps
+
+- Add more chat completion behaviors (specific text streaming, function calling, etc.)
+- Pin a specific OpenMockLLM version in the Dockerfile

src/backend/chat/agent_rag/document_rag_backends/albert_rag_backend.py

@@ -3,7 +3,7 @@
 import json
 import logging
 from io import BytesIO
-from typing import Optional
+from typing import List, Optional
 from urllib.parse import urljoin
 
 from django.conf import settings
@@ -18,6 +18,169 @@ from chat.agent_rag.document_rag_backends.base_rag_backend import BaseRagBackend
 
 logger = logging.getLogger(__name__)
 
+# Albert API token limit for document vectorization
+# We use a conservative chunk size to stay well under the limit
+ALBERT_MAX_TOKENS = 8192
+ALBERT_CHUNK_SIZE_TOKENS = 5000  # More conservative chunk size with larger safety margin
+# Approximate tokens: ~3 characters per token (more conservative estimate for Markdown/Excel)
+# Markdown and Excel content often have more tokens per character due to formatting
+ALBERT_CHUNK_SIZE_CHARS = ALBERT_CHUNK_SIZE_TOKENS * 3
+
+
+def _estimate_tokens(content: str) -> int:
+    """
+    Estimate the number of tokens in a text string.
+    
+    Uses a conservative approximation: ~3 characters per token.
+    This is more conservative than 4 chars/token to account for:
+    - Markdown formatting (headers, lists, tables)
+    - Excel content with special characters
+    - Whitespace and punctuation
+    
+    Args:
+        content (str): The text content to estimate.
+        
+    Returns:
+        int: Estimated number of tokens.
+    """
+    return len(content) // 3
+
+
+def _chunk_content(content: str, max_chars: int = ALBERT_CHUNK_SIZE_CHARS) -> List[str]:
+    """
+    Split content into chunks that fit within Albert's token limit.
+    
+    Attempts to split at paragraph boundaries (double newlines) when possible,
+    otherwise splits at line boundaries, and finally at character boundaries.
+    Validates that each chunk is under the token limit after splitting.
+    
+    Args:
+        content (str): The content to chunk.
+        max_chars (int): Maximum characters per chunk (default: ALBERT_CHUNK_SIZE_CHARS).
+        
+    Returns:
+        list[str]: List of content chunks, each under the token limit.
+    """
+    # First check if content fits in one chunk
+    estimated_tokens = _estimate_tokens(content)
+    if estimated_tokens <= ALBERT_CHUNK_SIZE_TOKENS:
+        return [content]
+    
+    chunks = []
+    remaining = content
+    
+    while len(remaining) > 0:
+        # Check if remaining content fits in one chunk
+        remaining_tokens = _estimate_tokens(remaining)
+        if remaining_tokens <= ALBERT_CHUNK_SIZE_TOKENS:
+            if remaining.strip():
+                chunks.append(remaining.strip())
+            break
+        
+        # Need to split - find the best split point
+        # Start with max_chars but may need to reduce if token estimate is too high
+        search_limit = max_chars
+        
+        # Try to find a split point that keeps us under token limit
+        # Reduce search limit if needed to ensure token limit is respected
+        while search_limit > 100:  # Minimum chunk size
+            # Try to split at paragraph boundary (double newline)
+            split_pos = remaining.rfind("\n\n", 0, search_limit)
+            if split_pos == -1:
+                # Try to split at single newline
+                split_pos = remaining.rfind("\n", 0, search_limit)
+            if split_pos == -1:
+                # Force split at character boundary
+                split_pos = search_limit
+            
+            # Validate that this chunk is under token limit
+            chunk_candidate = remaining[:split_pos].strip()
+            if chunk_candidate:
+                chunk_tokens = _estimate_tokens(chunk_candidate)
+                if chunk_tokens <= ALBERT_CHUNK_SIZE_TOKENS:
+                    chunks.append(chunk_candidate)
+                    remaining = remaining[split_pos:].lstrip()
+                    break
+            
+            # Chunk too large, reduce search limit and try again
+            search_limit = int(search_limit * 0.8)  # Reduce by 20%
+        else:
+            # Fallback: force split at a safe size
+            # This should rarely happen, but ensures we don't get stuck
+            safe_size = min(max_chars, len(remaining))
+            chunk = remaining[:safe_size].strip()
+            if chunk:
+                chunks.append(chunk)
+            remaining = remaining[safe_size:].lstrip()
+    
+    # Validate all chunks are under limit and split further if needed
+    validated_chunks = []
+    for chunk_item in chunks:
+        chunk_tokens = _estimate_tokens(chunk_item)
+        if chunk_tokens > ALBERT_MAX_TOKENS:
+            logger.warning(
+                "Chunk still exceeds token limit (%d tokens, max: %d), forcing split further",
+                chunk_tokens,
+                ALBERT_MAX_TOKENS,
+            )
+            # Force split this chunk further using a more conservative size
+            # Use a size that ensures we stay well under the token limit
+            # Target: ~5000 tokens max per chunk (conservative)
+            max_safe_chars = ALBERT_CHUNK_SIZE_TOKENS * 3  # 6000 * 3 = 18000 chars for ~5000 tokens
+            remaining_chunk = chunk_item
+            while len(remaining_chunk) > 0:
+                remaining_tokens = _estimate_tokens(remaining_chunk)
+                if remaining_tokens <= ALBERT_CHUNK_SIZE_TOKENS:
+                    if remaining_chunk.strip():
+                        validated_chunks.append(remaining_chunk.strip())
+                    break
+                
+                # Find a safe split point
+                split_pos = min(max_safe_chars, len(remaining_chunk))
+                # Try to split at a line boundary if possible
+                line_split = remaining_chunk.rfind("\n", 0, split_pos)
+                if line_split > max_safe_chars * 0.5:  # Only use if it's not too small
+                    split_pos = line_split
+                
+                sub_chunk = remaining_chunk[:split_pos].strip()
+                if sub_chunk:
+                    sub_tokens = _estimate_tokens(sub_chunk)
+                    # Double-check this sub-chunk is safe
+                    if sub_tokens > ALBERT_MAX_TOKENS:
+                        # Still too large, use even smaller size
+                        logger.warning(
+                            "Sub-chunk still too large (%d tokens), using smaller split",
+                            sub_tokens,
+                        )
+                        split_pos = ALBERT_CHUNK_SIZE_TOKENS * 2  # 12000 chars for ~3000 tokens
+                        sub_chunk = remaining_chunk[:split_pos].strip()
+                    validated_chunks.append(sub_chunk)
+                remaining_chunk = remaining_chunk[split_pos:].lstrip()
+        else:
+            validated_chunks.append(chunk_item)
+    
+    # Final validation - ensure NO chunk exceeds the limit
+    final_chunks = []
+    for chunk in validated_chunks:
+        chunk_tokens = _estimate_tokens(chunk)
+        if chunk_tokens > ALBERT_MAX_TOKENS:
+            logger.error(
+                "CRITICAL: Chunk still exceeds limit after all splitting attempts: %d tokens",
+                chunk_tokens,
+            )
+            # Emergency split: use very conservative size
+            emergency_size = ALBERT_CHUNK_SIZE_TOKENS * 2  # 12000 chars
+            remaining = chunk
+            while len(remaining) > 0:
+                emergency_chunk = remaining[:emergency_size].strip()
+                if emergency_chunk:
+                    final_chunks.append(emergency_chunk)
+                remaining = remaining[emergency_size:].lstrip()
+        else:
+            final_chunks.append(chunk)
+    
+    return final_chunks
+
 
 class AlbertRagBackend(BaseRagBackend):  # pylint: disable=too-many-instance-attributes
     """
@@ -33,9 +196,13 @@ class AlbertRagBackend(BaseRagBackend):  # pylint: disable=too-many-instance-att
     - Perform a search operation using the Albert API.
     """
 
-    def __init__(self, collection_id: Optional[str] = None):
+    def __init__(
+        self,
+        collection_id: Optional[str] = None,
+        read_only_collection_id: Optional[List[str]] = None,
+    ):
         # Initialize any necessary parameters or configurations here
-        super().__init__(collection_id)
+        super().__init__(collection_id, read_only_collection_id)
         self._base_url = settings.ALBERT_API_URL
         self._headers = {
             "Authorization": f"Bearer {settings.ALBERT_API_KEY}",
@@ -166,7 +333,42 @@ class AlbertRagBackend(BaseRagBackend):  # pylint: disable=too-many-instance-att
         """
         Store the document content in the Albert collection.
         This method should handle the logic to send the document content to the Albert API.
+        
+        If the document is too large (exceeds Albert's token limit), it will be automatically
+        split into multiple chunks and stored as separate documents.
 
+        Args:
+            name (str): The name of the document.
+            content (str): The content of the document in Markdown format.
+        """
+        # Check if content needs to be chunked
+        estimated_tokens = _estimate_tokens(content)
+        
+        if estimated_tokens > ALBERT_MAX_TOKENS:
+            logger.info(
+                "Document '%s' is too large (%d estimated tokens, limit: %d). "
+                "Splitting into chunks.",
+                name,
+                estimated_tokens,
+                ALBERT_MAX_TOKENS,
+            )
+            chunks = _chunk_content(content)
+            logger.info("Split document '%s' into %d chunks", name, len(chunks))
+            
+            # Store each chunk as a separate document
+            for i, chunk in enumerate(chunks, start=1):
+                chunk_name = f"{name}_part_{i}" if len(chunks) > 1 else name
+                self._store_single_document(chunk_name, chunk)
+        else:
+            # Document fits within limit, store as-is
+            self._store_single_document(name, content)
+    
+    def _store_single_document(self, name: str, content: str) -> None:
+        """
+        Store a single document chunk in the Albert collection.
+        
+        Internal method that performs the actual API call to store one document.
+        
         Args:
             name (str): The name of the document.
             content (str): The content of the document in Markdown format.
@@ -181,14 +383,68 @@ class AlbertRagBackend(BaseRagBackend):  # pylint: disable=too-many-instance-att
             },
             timeout=settings.ALBERT_API_TIMEOUT,
         )
-        logger.debug(response.json())
+        logger.debug("Stored document '%s': %s", name, response.json())
         response.raise_for_status()
 
     async def astore_document(self, name: str, content: str) -> None:
         """
         Store the document content in the Albert collection.
         This method should handle the logic to send the document content to the Albert API.
+        
+        If the document is too large (exceeds Albert's token limit), it will be automatically
+        split into multiple chunks and stored as separate documents.
 
+        Args:
+            name (str): The name of the document.
+            content (str): The content of the document in Markdown format.
+        """
+        # Check if content needs to be chunked
+        estimated_tokens = _estimate_tokens(content)
+        
+        if estimated_tokens > ALBERT_MAX_TOKENS:
+            logger.info(
+                "Document '%s' is too large (%d estimated tokens, limit: %d). "
+                "Splitting into chunks.",
+                name,
+                estimated_tokens,
+                ALBERT_MAX_TOKENS,
+            )
+            chunks = _chunk_content(content)
+            logger.info("Split document '%s' into %d chunks", name, len(chunks))
+            
+            # Validate chunks before storing
+            for i, chunk in enumerate(chunks, start=1):
+                chunk_tokens = _estimate_tokens(chunk)
+                logger.debug(
+                    "Chunk %d/%d: %d chars, ~%d tokens",
+                    i,
+                    len(chunks),
+                    len(chunk),
+                    chunk_tokens,
+                )
+                if chunk_tokens > ALBERT_MAX_TOKENS:
+                    logger.error(
+                        "Chunk %d/%d still exceeds token limit: %d tokens (max: %d)",
+                        i,
+                        len(chunks),
+                        chunk_tokens,
+                        ALBERT_MAX_TOKENS,
+                    )
+            
+            # Store each chunk as a separate document
+            for i, chunk in enumerate(chunks, start=1):
+                chunk_name = f"{name}_part_{i}" if len(chunks) > 1 else name
+                await self._astore_single_document(chunk_name, chunk)
+        else:
+            # Document fits within limit, store as-is
+            await self._astore_single_document(name, content)
+    
+    async def _astore_single_document(self, name: str, content: str) -> None:
+        """
+        Store a single document chunk in the Albert collection.
+        
+        Internal method that performs the actual API call to store one document.
+        
         Args:
             name (str): The name of the document.
             content (str): The content of the document in Markdown format.
@@ -206,7 +462,7 @@ class AlbertRagBackend(BaseRagBackend):  # pylint: disable=too-many-instance-att
                 },
                 timeout=settings.ALBERT_API_TIMEOUT,
             )
-            logger.debug(response.json())
+            logger.debug("Stored document '%s': %s", name, response.json())
             response.raise_for_status()
 
     def search(self, query, results_count: int = 4) -> RAGWebResults:
@@ -220,11 +476,13 @@ class AlbertRagBackend(BaseRagBackend):  # pylint: disable=too-many-instance-att
         Returns:
             RAGWebResults: The search results.
         """
+        collection_ids = self.get_all_collection_ids()  # might raise RuntimeError
+
         response = requests.post(
             urljoin(self._base_url, self._search_endpoint),
             headers=self._headers,
             json={
-                "collections": [int(self.collection_id)],
+                "collections": collection_ids,
                 "prompt": query,
                 "score_threshold": 0.6,
                 "k": results_count,  # Number of chunks to return from the search
@@ -261,12 +519,14 @@ class AlbertRagBackend(BaseRagBackend):  # pylint: disable=too-many-instance-att
         Returns:
             RAGWebResults: The search results.
         """
+        collection_ids = self.get_all_collection_ids()  # might raise RuntimeError
+
         async with httpx.AsyncClient(timeout=settings.ALBERT_API_TIMEOUT) as client:
             response = await client.post(
                 urljoin(self._base_url, self._search_endpoint),
                 headers=self._headers,
                 json={
-                    "collections": [int(self.collection_id)],
+                    "collections": collection_ids,
                     "prompt": query,
                     "score_threshold": 0.6,
                     "k": results_count,  # Number of chunks to return from the search

src/backend/chat/agent_rag/document_rag_backends/base_rag_backend.py

@@ -3,7 +3,7 @@
 import logging
 from contextlib import asynccontextmanager, contextmanager
 from io import BytesIO
-from typing import Optional
+from typing import List, Optional
 
 from asgiref.sync import sync_to_async
 
@@ -15,11 +15,51 @@ logger = logging.getLogger(__name__)
 class BaseRagBackend:
     """Base class for RAG backends."""
 
-    def __init__(self, collection_id: Optional[str] = None):
-        """Backend settings."""
+    def __init__(
+        self,
+        collection_id: Optional[str] = None,
+        read_only_collection_id: Optional[List[str]] = None,
+    ):
+        """
+        Backend settings.
+
+        Collection ID is required for RAG operations, where you want to manage the collection
+        lifecycle (create/delete).
+        Read-only collection IDs can be used to access existing collections
+        without managing their lifecycle.
+
+        Collection ID and read-only collection IDs are separated in the implementation to prevent
+        unwanted actions.
+
+        Args:
+            collection_id (Optional[str]): The collection ID for managing the collection lifecycle.
+            read_only_collection_id (Optional[List[str]]): List of read-only collection IDs.
+        """
         self.collection_id = collection_id
+        self.read_only_collection_id = read_only_collection_id or []
         self._default_collection_description = "Temporary collection for RAG document search"
 
+    def get_all_collection_ids(self) -> List[str]:
+        """
+        Get all collection IDs, including the main collection ID and read-only collection IDs.
+
+        Returns:
+            List[str]: List of all collection IDs.
+        Raises:
+            RuntimeError: If neither collection_id nor read_only_collection_id is provided.
+        """
+        if not self.collection_id and not self.read_only_collection_id:
+            raise RuntimeError("The RAG backend requires collection_id or read_only_collection_id")
+
+        collection_ids = []
+        if self.collection_id:
+            collection_ids.append(int(self.collection_id))
+        if self.read_only_collection_id:
+            collection_ids.extend(
+                [int(collection_id) for collection_id in self.read_only_collection_id]
+            )
+        return collection_ids
+
     def create_collection(self, name: str, description: Optional[str] = None) -> str:
         """
         Create a temporary collection for the search operation.

src/backend/chat/agents/base.py

@@ -190,6 +190,4 @@ class BaseAgent(Agent):
 
         _tools = [get_pydantic_tools_by_name(tool_name) for tool_name in self.configuration.tools]
 
-        super().__init__(
-            model=_model_instance, system_prompt=_system_prompt, tools=_tools, **kwargs
-        )
+        super().__init__(model=_model_instance, instructions=_system_prompt, tools=_tools, **kwargs)

src/backend/chat/agents/conversation.py

@@ -16,7 +16,6 @@ from .base import BaseAgent
 
 logger = logging.getLogger(__name__)
 
-
 MOCKED_RESPONSE = """
 # **Ode to the AI Assistant** 🤖✨
 
@@ -102,10 +101,10 @@ class ConversationAgent(BaseAgent):
         if settings.WARNING_MOCK_CONVERSATION_AGENT:
             self._model = FunctionModel(stream_function=mocked_agent_model)
 
-        @self.system_prompt
+        @self.instructions
         def add_the_date() -> str:
             """
-            Dynamic system prompt function to add the current date.
+            Dynamic instruction function to add the current date.
 
             Warning: this will always use the date in the server timezone,
             not the user's timezone...
@@ -113,9 +112,9 @@ class ConversationAgent(BaseAgent):
             _formatted_date = formats.date_format(timezone.now(), "l d/m/Y", use_l10n=False)
             return f"Today is {_formatted_date}."
 
-        @self.system_prompt
+        @self.instructions
         def enforce_response_language() -> str:
-            """Dynamic system prompt function to set the expected language to use."""
+            """Dynamic instruction function to set the expected language to use."""
             return f"Answer in {get_language_name(language).lower()}." if language else ""
 
     def get_web_search_tool_name(self) -> str | None:

src/backend/chat/clients/pydantic_ai.py

@@ -26,7 +26,7 @@ from django.utils.module_loading import import_string
 
 from asgiref.sync import sync_to_async
 from langfuse import get_client
-from pydantic_ai import Agent, RunContext
+from pydantic_ai import Agent, InstrumentationSettings, RunContext
 from pydantic_ai.messages import (
     BinaryContent,
     DocumentUrl,
@@ -72,11 +72,16 @@ from chat.clients.pydantic_ui_message_converter import (
     ui_message_to_user_content,
 )
 from chat.mcp_servers import get_mcp_servers
+from chat.tools.data_analysis import add_data_analysis_tool
+from chat.tools.document_generic_search_rag import add_document_rag_search_tool_from_setting
 from chat.tools.document_search_rag import add_document_rag_search_tool
 from chat.tools.document_summarize import document_summarize
 from chat.vercel_ai_sdk.core import events_v4, events_v5
 from chat.vercel_ai_sdk.encoder import EventEncoder
 
+# Keep at the top of the file to avoid mocking issues
+document_store_backend = import_string(settings.RAG_DOCUMENT_SEARCH_BACKEND)
+
 logger = logging.getLogger(__name__)
 
 User = get_user_model()
@@ -116,7 +121,8 @@ class AIAgentService:  # pylint: disable=too-many-instance-attributes
         self.language = language  # might be None
         self._last_stop_check = 0
 
-        self._store_analytics = settings.LANGFUSE_ENABLED and user.allow_conversation_analytics
+        self._langfuse_available = settings.LANGFUSE_ENABLED
+        self._store_analytics = self._langfuse_available and user.allow_conversation_analytics
         self.event_encoder = EventEncoder("v4")  # Always use v4 for now
 
         self._support_streaming = True
@@ -137,9 +143,16 @@ class AIAgentService:  # pylint: disable=too-many-instance-attributes
         self.conversation_agent = ConversationAgent(
             model_hrid=self.model_hrid,
             language=self.language,
-            instrument=self._store_analytics,
+            instrument=InstrumentationSettings(
+                include_binary_content=self._store_analytics,
+                include_content=self._store_analytics,
+            )
+            if self._langfuse_available
+            else False,
             deps_type=ContextDeps,
         )
+        add_document_rag_search_tool_from_setting(self.conversation_agent, self.user)
+        add_data_analysis_tool(self.conversation_agent)
 
     @property
     def _stop_cache_key(self):
@@ -174,7 +187,7 @@ class AIAgentService:  # pylint: disable=too-many-instance-attributes
         """Return only the assistant text deltas (legacy text mode)."""
         await self._clean()
         with ExitStack() as stack:
-            if self._store_analytics:
+            if self._langfuse_available:
                 span = stack.enter_context(get_client().start_as_current_span(name="conversation"))
                 span.update_trace(user_id=str(self.user.sub), session_id=str(self.conversation.pk))
 
@@ -186,7 +199,7 @@ class AIAgentService:  # pylint: disable=too-many-instance-attributes
         """Return Vercel-AI-SDK formatted events."""
         await self._clean()
         with ExitStack() as stack:
-            if self._store_analytics:
+            if self._langfuse_available:
                 span = stack.enter_context(get_client().start_as_current_span(name="conversation"))
                 span.update_trace(user_id=str(self.user.sub), session_id=str(self.conversation.pk))
             async for event in self._run_agent(messages, force_web_search):
@@ -228,6 +241,7 @@ class AIAgentService:  # pylint: disable=too-many-instance-attributes
         Parse and store input documents in the conversation's document store.
         """
         # Early external document URL rejection
+
         if any(
             not document.url.startswith("/media-key/")
             for document in documents
@@ -241,8 +255,6 @@ class AIAgentService:  # pylint: disable=too-many-instance-attributes
         ):
             raise ValueError("Document URL does not belong to the conversation.")
 
-        document_store_backend = import_string(settings.RAG_DOCUMENT_SEARCH_BACKEND)
-
         document_store = document_store_backend(self.conversation.collection_id)
         if not document_store.collection_id:
             # Create a new collection for the conversation
@@ -279,7 +291,24 @@ class AIAgentService:  # pylint: disable=too-many-instance-attributes
                     content=document.data,
                 )
 
-            if not document.media_type.startswith("text/"):
+            # Don't convert tabular files (CSV, Excel) to Markdown - keep originals for data_analysis tool
+            # Tabular files are already text-based or can be used directly
+            is_tabular_file = (
+                document.media_type in [
+                    "text/csv",
+                    "application/csv",
+                    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+                    "application/vnd.ms-excel",
+                    "application/excel",
+                ]
+                or any(
+                    document.identifier.lower().endswith(ext)
+                    for ext in [".csv", ".xlsx", ".xls", ".xlsm", ".xlsb"]
+                )
+            )
+            
+            # Only convert non-text files that are not tabular files
+            if not document.media_type.startswith("text/") and not is_tabular_file:
                 md_attachment = await models.ChatConversationAttachment.objects.acreate(
                     conversation=self.conversation,
                     uploaded_by=self.user,
@@ -353,7 +382,7 @@ class AIAgentService:  # pylint: disable=too-many-instance-attributes
             return
 
         # Langfuse settings
-        if self._store_analytics:
+        if self._langfuse_available:
             langfuse = get_client()
             langfuse.update_current_trace(
                 session_id=str(self.conversation.pk),
@@ -377,8 +406,10 @@ class AIAgentService:  # pylint: disable=too-many-instance-attributes
                 self.conversation, input_images, updated_url=image_key_mapping
             )
 
-        if self._store_analytics:
-            langfuse.update_current_trace(input=user_prompt)
+        if self._langfuse_available:
+            langfuse.update_current_trace(
+                input=user_prompt if self._store_analytics else "REDACTED"
+            )
 
         usage = {"promptTokens": 0, "completionTokens": 0}
 
@@ -410,6 +441,7 @@ class AIAgentService:  # pylint: disable=too-many-instance-attributes
                     ],
                 },
             )
+
             try:
                 await self.parse_input_documents(input_documents)
             except Exception as exc:  # pylint: disable=broad-except
@@ -447,7 +479,7 @@ class AIAgentService:  # pylint: disable=too-many-instance-attributes
 
         if force_web_search:
 
-            @self.conversation_agent.system_prompt
+            @self.conversation_agent.instructions
             def force_web_search_prompt() -> str:
                 """Dynamic system prompt function to force web search."""
                 return (
@@ -474,6 +506,7 @@ class AIAgentService:  # pylint: disable=too-many-instance-attributes
             .aexists()
         )
 
+
         document_urls = []
         if not conversation_has_documents and not has_not_pdf_docs:
             # No documents to process
@@ -495,7 +528,7 @@ class AIAgentService:  # pylint: disable=too-many-instance-attributes
                 )
 
             # Inform the model (system-level) that documents are attached and available
-            @self.conversation_agent.system_prompt
+            @self.conversation_agent.instructions
             def attached_documents_note() -> str:
                 return (
                     "[Internal context] User documents are attached to this conversation. "
@@ -508,6 +541,13 @@ class AIAgentService:  # pylint: disable=too-many-instance-attributes
             async def summarize(ctx: RunContext, *args, **kwargs) -> ToolReturn:
                 """Wrap the document_summarize tool to provide context and add the tool."""
                 return await document_summarize(ctx, *args, **kwargs)
+
+        if not conversation_has_documents and not has_not_pdf_docs:
+            # No documents to process
+            pass
+        elif has_not_pdf_docs:
+            # Already handled above with RAG tool
+            pass
         else:
             conversation_documents = [
                 cd
@@ -693,7 +733,7 @@ class AIAgentService:  # pylint: disable=too-many-instance-attributes
                             logger.error("_model_response_message_id already set")
                         _model_response_message_id = (
                             str(uuid.uuid4())
-                            if not self._store_analytics
+                            if not self._langfuse_available
                             else f"trace-{langfuse.get_current_trace_id()}"
                         )
                         yield events_v4.StartStepPart(
@@ -717,9 +757,10 @@ class AIAgentService:  # pylint: disable=too-many-instance-attributes
             image_key_mapping=image_key_mapping or None,
         )
 
-        if self._store_analytics:
-            langfuse.update_current_trace(output=run.result.output)
-
+        if self._langfuse_available:
+            langfuse.update_current_trace(
+                output=run.result.output if self._store_analytics else "REDACTED"
+            )
         # Vercel finish message
         yield events_v4.FinishMessagePart(
             finish_reason=events_v4.FinishReason.STOP,

src/backend/chat/tests/agents/test_build_conversation_agent.py

@@ -27,9 +27,14 @@ def test_build_pydantic_agent_success_no_tools():
     """Test successful agent creation without tools."""
     agent = ConversationAgent(model_hrid="default-model")
     assert isinstance(agent, Agent)
+    assert agent._system_prompts == ()
+
+    instructions = agent._instructions
+    assert len(instructions) == 3
+    assert instructions[0] == "You are a helpful assistant"
+    assert instructions[1].__name__ == "add_the_date"
+    assert instructions[2].__name__ == "enforce_response_language"
 
-    assert agent._system_prompts == ("You are a helpful assistant",)
-    assert agent._instructions == []
     assert isinstance(agent.model, OpenAIChatModel)
     assert agent.model.model_name == "model-123"
     assert str(agent.model.client.base_url) == "https://api.llm.com/v1/"
@@ -37,6 +42,7 @@ def test_build_pydantic_agent_success_no_tools():
     assert agent._function_toolset.tools == {}
 
 
+@freeze_time("2025-07-25T10:36:35.297675Z")
 def test_build_pydantic_agent_with_tools(settings):
     """Test successful agent creation with tools."""
     settings.AI_AGENT_TOOLS = ["get_current_weather"]
@@ -44,8 +50,14 @@ def test_build_pydantic_agent_with_tools(settings):
     agent = ConversationAgent(model_hrid="default-model")
     assert isinstance(agent, Agent)
 
-    assert agent._system_prompts == ("You are a helpful assistant",)
-    assert agent._instructions == []
+    instructions = agent._instructions
+    assert len(instructions) == 3
+    assert instructions[0] == "You are a helpful assistant"
+    assert instructions[1].__name__ == "add_the_date"
+    assert instructions[1]() == "Today is Friday 25/07/2025."
+    assert instructions[2].__name__ == "enforce_response_language"
+    assert instructions[2]() == ""
+
     assert isinstance(agent.model, OpenAIChatModel)
     assert agent.model.model_name == "model-123"
     assert str(agent.model.client.base_url) == "https://api.llm.com/v1/"
@@ -56,21 +68,23 @@ def test_build_pydantic_agent_with_tools(settings):
 @freeze_time("2025-07-25T10:36:35.297675Z")
 def test_add_dynamic_system_prompt():
     """
-    Ensure add_the_date and enforce_response_language system prompt are registered
+    Ensure add_the_date and enforce_response_language instructions are registered
     and returns proper values.
     """
     agent = ConversationAgent(model_hrid="default-model")
 
-    assert len(agent._system_prompt_functions) == 2
+    assert len(agent._system_prompt_functions) == 0
 
-    assert agent._system_prompt_functions[0].function.__name__ == "add_the_date"
-    assert agent._system_prompt_functions[0].function() == "Today is Friday 25/07/2025."
-
-    assert agent._system_prompt_functions[1].function.__name__ == "enforce_response_language"
-    assert agent._system_prompt_functions[1].function() == ""
+    instructions = agent._instructions
+    assert len(instructions) == 3
+    assert instructions[0] == "You are a helpful assistant"
+    assert instructions[1].__name__ == "add_the_date"
+    assert instructions[1]() == "Today is Friday 25/07/2025."
+    assert instructions[2].__name__ == "enforce_response_language"
+    assert instructions[2]() == ""
 
     agent = ConversationAgent(model_hrid="default-model", language="fr-fr")
-    assert agent._system_prompt_functions[1].function() == "Answer in french."
+    assert agent._instructions[2]() == "Answer in french."
 
 
 def test_agent_get_web_search_tool_name(settings):

src/backend/chat/tests/clients/pydantic_ai/test_add_document_rag_search_tool_from_setting.py

@@ -0,0 +1,66 @@
+"""Unit tests for add_document_rag_search_tool_from_setting integration with AIAgentService."""
+
+import pytest
+
+from core.factories import UserFactory
+
+from chat.clients.pydantic_ai import AIAgentService
+from chat.factories import ChatConversationFactory
+from chat.llm_configuration import LLModel, LLMProvider
+
+pytestmark = pytest.mark.django_db()
+
+
+def test_ai_agent_service_adds_rag_tools_from_settings(settings):
+    """Test that AIAgentService adds RAG tools from SPECIFIC_RAG_DOCUMENT_SEARCH_TOOLS."""
+    settings.LLM_CONFIGURATIONS = {
+        "default-model": LLModel(
+            hrid="default-model",
+            model_name="amazing-llm",
+            human_readable_name="Amazing LLM",
+            is_active=True,
+            icon=None,
+            system_prompt="You are an amazing assistant.",
+            tools=[],
+            provider=LLMProvider(hrid="unused", base_url="https://example.com", api_key="key"),
+        ),
+    }
+    settings.SPECIFIC_RAG_DOCUMENT_SEARCH_TOOLS = {
+        "legal_documents": {
+            "collection_ids": [100, 101, 102],
+            "feature_flag_value": "enabled",
+            "tool_description": "Use this tool to search legal documents and laws.",
+        },
+        "french_public_services": {
+            "collection_ids": [784, 785],
+            "feature_flag_value": "enabled",
+            "tool_description": (
+                "Use this tool when the user asks for information about French public services."
+            ),
+        },
+    }
+
+    user = UserFactory()
+    conversation = ChatConversationFactory(owner=user)
+
+    # Create the service
+    service = AIAgentService(conversation, user=user)
+
+    # Check that tools were added to the conversation_agent
+    agent_tools = service.conversation_agent._function_toolset.tools  # pylint: disable=protected-access
+
+    assert "legal_documents" in agent_tools
+    assert "french_public_services" in agent_tools
+
+    # Verify tool names and descriptions
+    assert agent_tools["legal_documents"].name == "legal_documents"
+    assert (
+        agent_tools["legal_documents"].description
+        == "Use this tool to search legal documents and laws."
+    )
+
+    assert agent_tools["french_public_services"].name == "french_public_services"
+    assert (
+        agent_tools["french_public_services"].description
+        == "Use this tool when the user asks for information about French public services."
+    )

src/backend/chat/tests/clients/pydantic_ai/test_langfuse_tracing.py

@@ -0,0 +1,270 @@
+"""Unit tests for Langfuse tracing in AIAgentService."""
+
+import pytest
+import responses
+from asgiref.sync import sync_to_async
+from langfuse import Langfuse
+from pydantic_ai.messages import ModelMessage
+from pydantic_ai.models.function import AgentInfo, FunctionModel
+
+from core.factories import UserFactory
+
+from chat.ai_sdk_types import TextUIPart, UIMessage
+from chat.clients.pydantic_ai import AIAgentService
+from chat.factories import ChatConversationFactory
+
+pytestmark = pytest.mark.django_db()
+
+
+@pytest.fixture(name="langfuse_client", scope="function")
+def langfuse_client_fixture():
+    """Fixture to init langfuse for tests."""
+    langfuse_client = Langfuse(
+        public_key="pk-test-key",
+        secret_key="sk-test-key",
+        host="https://langfuse.example.com",
+        environment="test",
+        debug=True,
+    )
+    yield langfuse_client
+    langfuse_client._resources.prompt_cache._task_manager.shutdown()  # pylint: disable=protected-access
+    langfuse_client.shutdown()
+
+
+@pytest.fixture(autouse=True)
+def base_settings(settings):
+    """Set up base settings for the tests."""
+    settings.AI_BASE_URL = "https://api.llm.com/v1/"
+    settings.AI_API_KEY = "test-key"
+    settings.AI_MODEL = "model-123"
+    settings.AI_AGENT_INSTRUCTIONS = "You are a helpful assistant"
+    settings.AI_AGENT_TOOLS = []
+
+
+@pytest.fixture(name="ui_messages")
+def ui_messages_fixture():
+    """Fixture for test UI messages."""
+    return [
+        UIMessage(
+            id="msg-1",
+            role="user",
+            content="Hello, how are you?",
+            parts=[TextUIPart(type="text", text="Hello, how are you?")],
+        )
+    ]
+
+
+@pytest.fixture(name="agent_model")
+def agent_model_fixture():
+    """Fixture for agent model function."""
+
+    async def _agent_model(_messages: list[ModelMessage], _info: AgentInfo):
+        """Simple agent model that returns a fixed response."""
+        yield "Hello! I'm doing well, thank you for asking."
+
+    return FunctionModel(stream_function=_agent_model)
+
+
+@pytest.mark.asyncio
+@responses.activate
+async def test_langfuse_span_created_when_enabled_and_analytics_allowed(
+    agent_model, ui_messages, settings, langfuse_client
+):
+    """Test Langfuse span is created when enabled and user allows analytics."""
+    settings.LANGFUSE_ENABLED = True
+
+    # Mock Langfuse HTTP endpoints
+    responses.add(
+        responses.POST,
+        "https://langfuse.example.com/api/public/otel/v1/traces",
+        json={"success": True},
+        status=200,
+    )
+
+    # Create user with analytics enabled
+    user = await sync_to_async(UserFactory)(allow_conversation_analytics=True)
+    conversation = await sync_to_async(ChatConversationFactory)(owner=user)
+
+    service = AIAgentService(conversation, user=user)
+    results = []
+    with service.conversation_agent.override(model=agent_model):
+        async for result in service.stream_text_async(ui_messages):
+            results.append(result)
+
+    # Verify that results were generated
+    assert results == ["Hello! I'm doing well, thank you for asking."]
+
+    langfuse_client.flush()
+
+    # Verify Langfuse HTTP calls were made
+    assert len(responses.calls) == 1
+    assert (
+        responses.calls[0].request.url == "https://langfuse.example.com/api/public/otel/v1/traces"
+    )
+
+    # quite complex to parse the full body, so just check that expected output is in there
+    assert b"Hello! I'm doing well, thank you for asking." in responses.calls[0].request.body
+
+
+@pytest.mark.asyncio
+@responses.activate
+async def test_langfuse_span_created_when_enabled_and_analytics_disabled(
+    agent_model, ui_messages, settings, langfuse_client
+):
+    """Test Langfuse span is created even when user disallows analytics."""
+    settings.LANGFUSE_ENABLED = True
+
+    # Mock Langfuse HTTP endpoints
+    responses.add(
+        responses.POST,
+        "https://langfuse.example.com/api/public/otel/v1/traces",
+        json={"success": True},
+        status=200,
+    )
+
+    # Create user with analytics disabled
+    user = await sync_to_async(UserFactory)(allow_conversation_analytics=False)
+    conversation = await sync_to_async(ChatConversationFactory)(owner=user)
+
+    service = AIAgentService(conversation, user=user)
+    results = []
+    with service.conversation_agent.override(model=agent_model):
+        async for result in service.stream_text_async(ui_messages):
+            results.append(result)
+
+    # Verify that results were generated
+    assert results == ["Hello! I'm doing well, thank you for asking."]
+
+    langfuse_client.flush()
+
+    # Verify Langfuse HTTP calls were made
+    assert len(responses.calls) == 1
+    assert (
+        responses.calls[0].request.url == "https://langfuse.example.com/api/public/otel/v1/traces"
+    )
+
+    # quite complex to parse the full body, so just check that expected output is in there
+    assert b"Hello! I'm doing well, thank you for asking." not in responses.calls[0].request.body
+    assert b"REDACTED" in responses.calls[0].request.body
+
+
+@pytest.mark.asyncio
+@responses.activate
+async def test_no_langfuse_span_when_disabled(agent_model, ui_messages, settings, langfuse_client):
+    """Test Langfuse span is not created when Langfuse is disabled."""
+    settings.LANGFUSE_ENABLED = False
+
+    # Mock Langfuse HTTP endpoints (should not be called)
+    responses.add(
+        responses.POST,
+        "https://langfuse.example.com/api/public/ingestion",
+        json={"success": True},
+        status=200,
+    )
+
+    user = await sync_to_async(UserFactory)(allow_conversation_analytics=True)
+    conversation = await sync_to_async(ChatConversationFactory)(owner=user)
+
+    service = AIAgentService(conversation, user=user)
+    results = []
+    with service.conversation_agent.override(model=agent_model):
+        async for result in service.stream_text_async(ui_messages):
+            results.append(result)
+
+    # Verify that results were generated
+    assert results == ["Hello! I'm doing well, thank you for asking."]
+
+    langfuse_client.flush()
+
+    # Verify NO Langfuse HTTP calls were made
+    assert len(responses.calls) == 0
+
+
+@pytest.mark.asyncio
+async def test_instrumentation_settings_with_analytics_enabled(settings):
+    """Test service correctly sets flags when Langfuse and analytics are enabled."""
+    # pylint: disable=protected-access
+    settings.LANGFUSE_ENABLED = True
+
+    user = await sync_to_async(UserFactory)(allow_conversation_analytics=True)
+    conversation = await sync_to_async(ChatConversationFactory)(owner=user)
+    service = AIAgentService(conversation, user=user)
+
+    # Verify that flags are set correctly
+    assert service._langfuse_available is True
+    assert service._store_analytics is True
+    # ConversationAgent should be created successfully
+    assert service.conversation_agent is not None
+
+
+@pytest.mark.asyncio
+async def test_instrumentation_settings_with_analytics_disabled(settings):
+    """Test service correctly sets flags when Langfuse enabled but analytics disabled."""
+    # pylint: disable=protected-access
+    settings.LANGFUSE_ENABLED = True
+
+    user = await sync_to_async(UserFactory)(allow_conversation_analytics=False)
+    conversation = await sync_to_async(ChatConversationFactory)(owner=user)
+    service = AIAgentService(conversation, user=user)
+
+    # Verify that flags are set correctly
+    assert service._langfuse_available is True
+    assert service._store_analytics is False
+    # ConversationAgent should be created successfully
+    assert service.conversation_agent is not None
+
+
+@pytest.mark.asyncio
+async def test_instrumentation_disabled_when_langfuse_disabled(settings):
+    """Test service correctly sets flags when Langfuse is disabled."""
+    # pylint: disable=protected-access
+    settings.LANGFUSE_ENABLED = False
+
+    user = await sync_to_async(UserFactory)(allow_conversation_analytics=True)
+    conversation = await sync_to_async(ChatConversationFactory)(owner=user)
+    service = AIAgentService(conversation, user=user)
+
+    # Verify that flags are set correctly
+    assert service._langfuse_available is False
+    assert service._store_analytics is False
+    # ConversationAgent should be created successfully
+    assert service.conversation_agent is not None
+
+
+def test_store_analytics_flag_when_langfuse_enabled_and_user_allows(settings):
+    """Test _store_analytics is True when Langfuse enabled and user allows analytics."""
+    # pylint: disable=protected-access
+    settings.LANGFUSE_ENABLED = True
+
+    user = UserFactory(allow_conversation_analytics=True)
+    conversation = ChatConversationFactory(owner=user)
+
+    service = AIAgentService(conversation, user=user)
+    assert service._langfuse_available is True
+    assert service._store_analytics is True
+
+
+def test_store_analytics_flag_when_langfuse_enabled_and_user_disallows(settings):
+    """Test _store_analytics is False when Langfuse enabled but user disallows analytics."""
+    # pylint: disable=protected-access
+    settings.LANGFUSE_ENABLED = True
+
+    user = UserFactory(allow_conversation_analytics=False)
+    conversation = ChatConversationFactory(owner=user)
+
+    service = AIAgentService(conversation, user=user)
+    assert service._langfuse_available is True
+    assert service._store_analytics is False
+
+
+def test_store_analytics_flag_when_langfuse_disabled(settings):
+    """Test _store_analytics is False when Langfuse is disabled."""
+    # pylint: disable=protected-access
+    settings.LANGFUSE_ENABLED = False
+
+    user = UserFactory(allow_conversation_analytics=True)
+    conversation = ChatConversationFactory(owner=user)
+
+    service = AIAgentService(conversation, user=user)
+    assert service._langfuse_available is False
+    assert service._store_analytics is False

src/backend/chat/tests/tools/test_document_generic_search_rag.py

@@ -0,0 +1,403 @@
+"""
+Unit tests for document generic search RAG tool functionality.
+"""
+
+import json
+import logging
+
+import httpx
+import pytest
+import responses
+import respx
+from asgiref.sync import sync_to_async
+from pydantic_ai import Agent, RunContext, RunUsage
+
+from core.factories import UserFactory
+
+from chat.tools.document_generic_search_rag import (
+    add_document_rag_search_tool_from_setting,
+    get_specific_rag_search_tool_config,
+)
+
+pytestmark = pytest.mark.django_db()
+
+
+def test_get_specific_rag_search_tool_config_with_disabled_features(settings):
+    """Test get_specific_rag_search_tool_config returns tools for enabled features."""
+    user = UserFactory()
+
+    settings.SPECIFIC_RAG_DOCUMENT_SEARCH_TOOLS = {
+        "french_public_services": {
+            "collection_ids": [784, 785],
+            "feature_flag_value": "disabled",
+            "tool_description": (
+                "Use this tool when the user asks for information about French public services, "
+                "the French labor market, employment laws, social benefits, or "
+                "assistance with administrative procedures."
+            ),
+        },
+        "legal_documents": {
+            "collection_ids": [100, 101, 102],
+            "feature_flag_value": "disabled",
+            "tool_description": "Use this tool to search French legal documents and laws.",
+            "rag_backend_name": "chat.tests.tools.test_document_generic_search_rag.MockRagBackend",
+        },
+    }
+
+    # The fixture tools are disabled by default
+    assert get_specific_rag_search_tool_config(user) == {}
+
+
+def test_get_specific_rag_search_tool_config_with_enabled_features(settings):
+    """Test get_specific_rag_search_tool_config returns tools for enabled features."""
+    user = UserFactory()
+
+    settings.SPECIFIC_RAG_DOCUMENT_SEARCH_TOOLS = {
+        "french_public_services": {
+            "collection_ids": [784, 785],
+            "feature_flag_value": "enabled",
+            "tool_description": (
+                "Use this tool when the user asks for information about French public services, "
+                "the French labor market, employment laws, social benefits, or "
+                "assistance with administrative procedures."
+            ),
+        },
+        "legal_documents": {
+            "collection_ids": [100, 101, 102],
+            "feature_flag_value": "enabled",
+            "tool_description": "Use this tool to search French legal documents and laws.",
+        },
+    }
+
+    assert get_specific_rag_search_tool_config(user) == {
+        "french_public_services": {
+            "collection_ids": [784, 785],
+            "feature_flag_value": "enabled",
+            "tool_description": "Use this tool when the user "
+            "asks for information about "
+            "French public services, the "
+            "French labor market, "
+            "employment laws, social "
+            "benefits, or assistance with "
+            "administrative procedures.",
+        },
+        "legal_documents": {
+            "collection_ids": [100, 101, 102],
+            "feature_flag_value": "enabled",
+            "tool_description": "Use this tool to search French legal documents and laws.",
+        },
+    }
+
+
+@responses.activate
+def test_get_specific_rag_search_tool_config_with_dynamic_features(settings, posthog):
+    """Test get_specific_rag_search_tool_config with dynamic features."""
+    user = UserFactory()
+
+    responses.post(
+        f"{posthog.host}/flags/?v=2",
+        json={"flags": {"legal-documents": {"enabled": True}}},
+        status=200,
+    )
+
+    settings.SPECIFIC_RAG_DOCUMENT_SEARCH_TOOLS = {
+        "french_public_services": {
+            "collection_ids": [784, 785],
+            "feature_flag_value": "dynamic",
+            "tool_description": (
+                "Use this tool when the user asks for information about French public services, "
+                "the French labor market, employment laws, social benefits, or "
+                "assistance with administrative procedures."
+            ),
+        },
+        "legal_documents": {
+            "collection_ids": [100, 101, 102],
+            "feature_flag_value": "dynamic",
+            "tool_description": "Use this tool to search French legal documents and laws.",
+        },
+    }
+
+    assert get_specific_rag_search_tool_config(user) == {
+        "legal_documents": {
+            "collection_ids": [100, 101, 102],
+            "feature_flag_value": "dynamic",
+            "tool_description": "Use this tool to search French legal documents and laws.",
+        }
+    }
+
+
+def test_add_document_rag_search_tool_from_setting_adds_tools(settings):
+    """Test that add_document_rag_search_tool_from_setting adds tools to the agent."""
+    settings.SPECIFIC_RAG_DOCUMENT_SEARCH_TOOLS = {
+        "legal_documents": {
+            "collection_ids": [100, 101, 102],
+            "feature_flag_value": "enabled",
+            "tool_description": "Use this tool to search legal documents and laws.",
+        },
+    }
+
+    user = UserFactory()
+
+    agent = Agent("test")
+    assert len(agent._function_toolset.tools) == 0  # pylint: disable=protected-access
+
+    add_document_rag_search_tool_from_setting(agent, user)
+
+    # Check that tools were added
+    assert len(agent._function_toolset.tools) == 1  # pylint: disable=protected-access
+    assert agent._function_toolset.tools["legal_documents"].name == "legal_documents"  # pylint: disable=protected-access
+    assert (
+        agent._function_toolset.tools["legal_documents"].description  # pylint: disable=protected-access
+        == "Use this tool to search legal documents and laws."
+    )
+    assert agent._function_toolset.tools["legal_documents"].function_schema.json_schema == {  # pylint: disable=protected-access
+        "additionalProperties": False,
+        "properties": {
+            "query": {"description": "The query to search information about.", "type": "string"}
+        },
+        "required": ["query"],
+        "type": "object",
+    }
+
+
+def test_add_document_rag_search_tool_with_invalid_backend(settings, caplog):
+    """Test that invalid backend import is handled gracefully."""
+    caplog.set_level(logging.WARNING, logger="chat.tools.document_generic_search_rag")
+
+    settings.SPECIFIC_RAG_DOCUMENT_SEARCH_TOOLS = {
+        "legal_documents": {
+            "collection_ids": [100, 101, 102],
+            "rag_backend_name": "non.existent.Backend",
+            "feature_flag_value": "enabled",
+            "tool_description": "Use this tool to search legal documents and laws.",
+        },
+    }
+    user = UserFactory()
+    agent = Agent("test")
+
+    add_document_rag_search_tool_from_setting(agent, user)
+
+    # Tool should not be added due to import error
+    assert len(agent._function_toolset.tools) == 0  # pylint: disable=protected-access
+
+    # Check that warning was logged
+    assert len(caplog.records) == 1
+    assert "Could not import RAG backend non.existent.Backend" in caplog.records[0].message
+
+
+def test_add_document_rag_search_tool_with_missing_collection_ids(settings, caplog):
+    """Test that missing collection_ids is handled gracefully."""
+    caplog.set_level(logging.WARNING, logger="chat.tools.document_generic_search_rag")
+
+    settings.SPECIFIC_RAG_DOCUMENT_SEARCH_TOOLS = {
+        "legal_documents": {
+            "feature_flag_value": "enabled",
+            "tool_description": "Use this tool to search legal documents and laws.",
+        },
+    }
+    user = UserFactory()
+    agent = Agent("test")
+
+    add_document_rag_search_tool_from_setting(agent, user)
+
+    # Tool should not be added due to import error
+    assert len(agent._function_toolset.tools) == 0  # pylint: disable=protected-access
+
+    # Check that warning was logged
+    assert len(caplog.records) == 1
+    assert "No collection IDs provided for tool legal_documents" in caplog.records[0].message
+
+
+def test_add_document_rag_search_tool_with_missing_tool_description(settings, caplog):
+    """Test that missing tool_description is handled gracefully."""
+    caplog.set_level(logging.WARNING, logger="chat.tools.document_generic_search_rag")
+
+    settings.SPECIFIC_RAG_DOCUMENT_SEARCH_TOOLS = {
+        "legal_documents": {
+            "collection_ids": [100, 101, 102],
+            "feature_flag_value": "enabled",
+        },
+    }
+    user = UserFactory()
+    agent = Agent("test")
+
+    add_document_rag_search_tool_from_setting(agent, user)
+
+    # Tool should not be added due to import error
+    assert len(agent._function_toolset.tools) == 0  # pylint: disable=protected-access
+
+    # Check that warning was logged
+    assert len(caplog.records) == 1
+    assert "No tool description provided for tool legal_documents" in caplog.records[0].message
+
+
+@respx.mock
+def test_document_search_rag_tool_execution(settings):
+    """Test that the generated RAG tool executes correctly."""
+    search_mock = respx.post("https://albert.api.etalab.gouv.fr/v1/search").mock(
+        return_value=httpx.Response(
+            status_code=200,
+            json={
+                "data": [
+                    {
+                        "method": "semantic",
+                        "chunk": {
+                            "id": 1,
+                            "content": "Relevant content snippet.",
+                            "metadata": {"document_name": "doc1.txt"},
+                        },
+                        "score": 0.9,
+                    }
+                ],
+                "usage": {"prompt_tokens": 10, "completion_tokens": 20},
+            },
+        )
+    )
+    settings.SPECIFIC_RAG_DOCUMENT_SEARCH_TOOLS = {
+        "legal_documents": {
+            "collection_ids": [100, 101, 102],
+            "feature_flag_value": "enabled",
+            "tool_description": "Use this tool to search legal documents and laws.",
+        },
+        "legal_documents_2": {
+            "collection_ids": [200],
+            "feature_flag_value": "enabled",
+            "tool_description": "Use this tool to search legal documents and laws.",
+        },
+    }
+    user = UserFactory()
+    agent = Agent(model="test")
+
+    add_document_rag_search_tool_from_setting(agent, user)
+
+    result = agent.run_sync("What information can you find about French services?")
+
+    # Verify the result
+    assert json.loads(result.output) == {
+        "legal_documents": {"0": {"snippets": "Relevant content snippet.", "url": "doc1.txt"}},
+        "legal_documents_2": {"0": {"snippets": "Relevant content snippet.", "url": "doc1.txt"}},
+    }
+
+    assert len(search_mock.calls) == 2
+    assert json.loads(search_mock.calls[0].request.content) == {
+        "collections": [100, 101, 102],
+        "k": 4,
+        "prompt": "a",
+        "score_threshold": 0.6,
+    }
+    assert json.loads(search_mock.calls[1].request.content) == {
+        "collections": [200],
+        "k": 4,
+        "prompt": "a",
+        "score_threshold": 0.6,
+    }
+
+
+def test_get_specific_rag_search_tool_config_with_empty_settings(settings):
+    """Test get_specific_rag_search_tool_config with empty SPECIFIC_RAG_DOCUMENT_SEARCH_TOOLS."""
+    settings.SPECIFIC_RAG_DOCUMENT_SEARCH_TOOLS = {}
+
+    user = UserFactory()
+    config = get_specific_rag_search_tool_config(user)
+
+    assert config == {}
+
+
+@pytest.mark.asyncio
+@respx.mock
+async def test_add_document_rag_search_tool_function_call(settings):
+    """Test the function behavior."""
+    search_mock = respx.post("https://albert.api.etalab.gouv.fr/v1/search").mock(
+        return_value=httpx.Response(
+            status_code=200,
+            json={
+                "data": [
+                    {
+                        "method": "semantic",
+                        "chunk": {
+                            "id": 1,
+                            "content": "Relevant content snippet.",
+                            "metadata": {"document_name": "doc1.txt"},
+                        },
+                        "score": 0.9,
+                    }
+                ],
+                "usage": {"prompt_tokens": 10, "completion_tokens": 20},
+            },
+        )
+    )
+    settings.SPECIFIC_RAG_DOCUMENT_SEARCH_TOOLS = {
+        "legal_documents": {
+            "collection_ids": [100, 101, 102],
+            "feature_flag_value": "enabled",
+            "tool_description": "Use this tool to search legal documents and laws.",
+        },
+    }
+
+    user = await sync_to_async(UserFactory)()
+
+    agent = Agent("test")
+    add_document_rag_search_tool_from_setting(agent, user)
+
+    result = await agent._function_toolset.tools["legal_documents"].function(  # pylint: disable=protected-access
+        RunContext(model="test", usage=RunUsage(), deps={}),
+        query="Find information about French laws.",
+    )
+
+    assert result.return_value == {
+        "0": {"snippets": "Relevant content snippet.", "url": "doc1.txt"}
+    }
+    assert result.metadata == {"sources": {"doc1.txt"}}
+    assert len(search_mock.calls) == 1
+    assert json.loads(search_mock.calls[0].request.content) == {
+        "collections": [100, 101, 102],
+        "k": 4,
+        "prompt": "Find information about French laws.",
+        "score_threshold": 0.6,
+    }
+
+
+@pytest.mark.asyncio
+@respx.mock
+async def test_document_search_rag_http_status_error(settings, caplog):
+    """Test that HTTPStatusError is properly handled and logged."""
+    caplog.set_level(logging.ERROR, logger="chat.tools.document_generic_search_rag")
+
+    # Mock the API to return a 500 error
+    respx.post("https://albert.api.etalab.gouv.fr/v1/search").mock(
+        return_value=httpx.Response(
+            status_code=500,
+            json={"error": "Internal server error"},
+        )
+    )
+
+    settings.SPECIFIC_RAG_DOCUMENT_SEARCH_TOOLS = {
+        "legal_documents": {
+            "collection_ids": [100, 101, 102],
+            "feature_flag_value": "enabled",
+            "tool_description": "Use this tool to search legal documents and laws.",
+        },
+    }
+
+    user = await sync_to_async(UserFactory)()
+    agent = Agent("test")
+    add_document_rag_search_tool_from_setting(agent, user)
+
+    # Call the tool function and expect a ModelRetry to be raised and caught
+    tool_result = await agent._function_toolset.tools["legal_documents"].function(  # pylint: disable=protected-access
+        RunContext(model="test", usage=RunUsage(), deps={}),
+        query="Find information about French laws.",
+    )
+
+    # Verify the exception message
+    assert tool_result == (
+        "Document search service is currently unavailable: Server error '500 Internal "
+        "Server Error' for url 'https://albert.api.etalab.gouv.fr/v1/search'\n"
+        "For more information check: "
+        "https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/500 You must "
+        "explain this to the user and not try to answer based on your knowledge."
+    )
+
+    # Verify that error was logged
+    assert "RAG document search failed for tool legal_documents" in caplog.records[0].message
+    assert "Document search service is currently unavailable" in caplog.records[1].message

src/backend/chat/tests/views/chat/conversations/test_conversation.py

@@ -130,6 +130,16 @@ def test_post_conversation_data_protocol(api_client, mock_openai_stream):
 
     assert mock_openai_stream.called
 
+    # ensure instructions are merged as a system prompt
+    last_request_payload = json.loads(respx.calls.last.request.content)
+    assert last_request_payload["messages"][0] == {
+        "content": (
+            "You are a helpful test assistant :)\n\nToday is Friday 25/07/2025.\n\n"
+            "Answer in english."
+        ),
+        "role": "system",
+    }
+
     chat_conversation.refresh_from_db()
     assert chat_conversation.ui_messages == [
         {
@@ -169,35 +179,23 @@ def test_post_conversation_data_protocol(api_client, mock_openai_stream):
         parts=[TextUIPart(type="text", text="Hello there")],
     )
 
+    _run_id = chat_conversation.pydantic_messages[0]["run_id"]
+
     assert chat_conversation.pydantic_messages == [
         {
-            "instructions": None,
+            "instructions": (
+                "You are a helpful test assistant :)\n\n"
+                "Today is Friday 25/07/2025.\n\nAnswer in english."
+            ),
             "kind": "request",
             "parts": [
-                {
-                    "content": "You are a helpful test assistant :)",
-                    "dynamic_ref": None,
-                    "part_kind": "system-prompt",
-                    "timestamp": "2025-07-25T10:36:35.297675Z",
-                },
-                {
-                    "content": "Today is Friday 25/07/2025.",
-                    "dynamic_ref": None,
-                    "part_kind": "system-prompt",
-                    "timestamp": "2025-07-25T10:36:35.297675Z",
-                },
-                {
-                    "content": "Answer in english.",
-                    "dynamic_ref": None,
-                    "part_kind": "system-prompt",
-                    "timestamp": "2025-07-25T10:36:35.297675Z",
-                },
                 {
                     "content": ["Hello"],
                     "part_kind": "user-prompt",
                     "timestamp": "2025-07-25T10:36:35.297675Z",
                 },
             ],
+            "run_id": _run_id,
         },
         {
             "finish_reason": "stop",
@@ -218,6 +216,7 @@ def test_post_conversation_data_protocol(api_client, mock_openai_stream):
                 "output_audio_tokens": 0,
                 "output_tokens": 0,
             },
+            "run_id": _run_id,
         },
     ]
 
@@ -252,6 +251,15 @@ def test_post_conversation_text_protocol(api_client, mock_openai_stream):
     assert response_content == "Hello there"
 
     assert mock_openai_stream.called
+    # ensure instructions are merged as a system prompt
+    last_request_payload = json.loads(respx.calls.last.request.content)
+    assert last_request_payload["messages"][0] == {
+        "content": (
+            "You are a helpful test assistant :)\n\nToday is Friday 25/07/2025.\n\n"
+            "Answer in english."
+        ),
+        "role": "system",
+    }
 
     chat_conversation.refresh_from_db()
     assert chat_conversation.ui_messages == [
@@ -292,35 +300,23 @@ def test_post_conversation_text_protocol(api_client, mock_openai_stream):
         parts=[TextUIPart(type="text", text="Hello there")],
     )
 
+    _run_id = chat_conversation.pydantic_messages[0]["run_id"]
+
     assert chat_conversation.pydantic_messages == [
         {
-            "instructions": None,
+            "instructions": (
+                "You are a helpful test assistant :)\n\n"
+                "Today is Friday 25/07/2025.\n\nAnswer in english."
+            ),
             "kind": "request",
             "parts": [
-                {
-                    "content": "You are a helpful test assistant :)",
-                    "dynamic_ref": None,
-                    "part_kind": "system-prompt",
-                    "timestamp": "2025-07-25T10:36:35.297675Z",
-                },
-                {
-                    "content": "Today is Friday 25/07/2025.",
-                    "dynamic_ref": None,
-                    "part_kind": "system-prompt",
-                    "timestamp": "2025-07-25T10:36:35.297675Z",
-                },
-                {
-                    "content": "Answer in english.",
-                    "dynamic_ref": None,
-                    "part_kind": "system-prompt",
-                    "timestamp": "2025-07-25T10:36:35.297675Z",
-                },
                 {
                     "content": ["Hello"],
                     "part_kind": "user-prompt",
                     "timestamp": "2025-07-25T10:36:35.297675Z",
                 },
             ],
+            "run_id": _run_id,
         },
         {
             "finish_reason": "stop",
@@ -341,6 +337,7 @@ def test_post_conversation_text_protocol(api_client, mock_openai_stream):
                 "output_audio_tokens": 0,
                 "output_tokens": 0,
             },
+            "run_id": _run_id,
         },
     ]
 
@@ -403,11 +400,12 @@ def test_post_conversation_with_image(api_client, mock_openai_stream_image):
     # Check the exact structure expected by the AI service
     assert body["messages"] == [
         {
-            "content": "You are a helpful test assistant :)",
+            "content": (
+                "You are a helpful test assistant :)\n\nToday is Friday 25/07/2025."
+                "\n\nAnswer in english."
+            ),
             "role": "system",
         },
-        {"content": "Today is Friday 25/07/2025.", "role": "system"},
-        {"content": "Answer in english.", "role": "system"},
         {
             "content": [
                 {"text": "Hello, what do you see on this picture?", "type": "text"},
@@ -489,29 +487,15 @@ def test_post_conversation_with_image(api_client, mock_openai_stream_image):
         parts=[TextUIPart(type="text", text="I see a cat in the picture.")],
     )
 
+    _run_id = chat_conversation.pydantic_messages[0]["run_id"]
     assert chat_conversation.pydantic_messages == [
         {
-            "instructions": None,
+            "instructions": (
+                "You are a helpful test assistant :)\n\n"
+                "Today is Friday 25/07/2025.\n\nAnswer in english."
+            ),
             "kind": "request",
             "parts": [
-                {
-                    "content": "You are a helpful test assistant :)",
-                    "dynamic_ref": None,
-                    "part_kind": "system-prompt",
-                    "timestamp": "2025-07-25T10:36:35.297675Z",
-                },
-                {
-                    "content": "Today is Friday 25/07/2025.",
-                    "dynamic_ref": None,
-                    "part_kind": "system-prompt",
-                    "timestamp": "2025-07-25T10:36:35.297675Z",
-                },
-                {
-                    "content": "Answer in english.",
-                    "dynamic_ref": None,
-                    "part_kind": "system-prompt",
-                    "timestamp": "2025-07-25T10:36:35.297675Z",
-                },
                 {
                     "content": [
                         "Hello, what do you see on this picture?",
@@ -530,6 +514,7 @@ def test_post_conversation_with_image(api_client, mock_openai_stream_image):
                     "timestamp": "2025-07-25T10:36:35.297675Z",
                 },
             ],
+            "run_id": _run_id,
         },
         {
             "finish_reason": "stop",
@@ -550,6 +535,7 @@ def test_post_conversation_with_image(api_client, mock_openai_stream_image):
                 "output_audio_tokens": 0,
                 "output_tokens": 0,
             },
+            "run_id": _run_id,
         },
     ]
 
@@ -607,11 +593,12 @@ def test_post_conversation_tool_call(api_client, mock_openai_stream_tool, settin
 
     assert body["messages"] == [
         {
-            "content": "You are a helpful test assistant :)",
+            "content": (
+                "You are a helpful test assistant :)\n\n"
+                "Today is Friday 25/07/2025.\n\nAnswer in english."
+            ),
             "role": "system",
         },
-        {"content": "Today is Friday 25/07/2025.", "role": "system"},
-        {"content": "Answer in english.", "role": "system"},
         {"content": [{"text": "Weather in Paris?", "type": "text"}], "role": "user"},
     ]
 
@@ -666,35 +653,22 @@ def test_post_conversation_tool_call(api_client, mock_openai_stream_tool, settin
         ],
     )
 
+    _run_id = chat_conversation.pydantic_messages[0]["run_id"]
     assert chat_conversation.pydantic_messages == [
         {
-            "instructions": None,
+            "instructions": (
+                "You are a helpful test assistant :)\n\n"
+                "Today is Friday 25/07/2025.\n\nAnswer in english."
+            ),
             "kind": "request",
             "parts": [
-                {
-                    "content": "You are a helpful test assistant :)",
-                    "dynamic_ref": None,
-                    "part_kind": "system-prompt",
-                    "timestamp": "2025-07-25T10:36:35.297675Z",
-                },
-                {
-                    "content": "Today is Friday 25/07/2025.",
-                    "dynamic_ref": None,
-                    "part_kind": "system-prompt",
-                    "timestamp": "2025-07-25T10:36:35.297675Z",
-                },
-                {
-                    "content": "Answer in english.",
-                    "dynamic_ref": None,
-                    "part_kind": "system-prompt",
-                    "timestamp": "2025-07-25T10:36:35.297675Z",
-                },
                 {
                     "content": ["Weather in Paris?"],
                     "part_kind": "user-prompt",
                     "timestamp": "2025-07-25T10:36:35.297675Z",
                 },
             ],
+            "run_id": _run_id,
         },
         {
             "finish_reason": "tool_call",
@@ -723,9 +697,13 @@ def test_post_conversation_tool_call(api_client, mock_openai_stream_tool, settin
                 "output_audio_tokens": 0,
                 "output_tokens": 0,
             },
+            "run_id": _run_id,
         },
         {
-            "instructions": None,
+            "instructions": (
+                "You are a helpful test assistant :)\n\n"
+                "Today is Friday 25/07/2025.\n\nAnswer in english."
+            ),
             "kind": "request",
             "parts": [
                 {
@@ -737,6 +715,7 @@ def test_post_conversation_tool_call(api_client, mock_openai_stream_tool, settin
                     "tool_name": "get_current_weather",
                 }
             ],
+            "run_id": _run_id,
         },
         {
             "finish_reason": "stop",
@@ -759,6 +738,7 @@ def test_post_conversation_tool_call(api_client, mock_openai_stream_tool, settin
                 "output_audio_tokens": 0,
                 "output_tokens": 0,
             },
+            "run_id": _run_id,
         },
     ]
 
@@ -815,11 +795,12 @@ def test_post_conversation_tool_call_fails(api_client, mock_openai_stream_tool,
 
     assert body["messages"] == [
         {
-            "content": "You are a helpful test assistant :)",
+            "content": (
+                "You are a helpful test assistant :)\n\n"
+                "Today is Friday 25/07/2025.\n\nAnswer in french."
+            ),
             "role": "system",
         },
-        {"content": "Today is Friday 25/07/2025.", "role": "system"},
-        {"content": "Answer in french.", "role": "system"},
         {"content": [{"text": "Weather in Paris?", "type": "text"}], "role": "user"},
     ]
 
@@ -874,35 +855,22 @@ def test_post_conversation_tool_call_fails(api_client, mock_openai_stream_tool,
         ],
     )
 
+    _run_id = chat_conversation.pydantic_messages[0]["run_id"]
     assert chat_conversation.pydantic_messages == [
         {
-            "instructions": None,
+            "instructions": (
+                "You are a helpful test assistant :)\n\n"
+                "Today is Friday 25/07/2025.\n\nAnswer in french."
+            ),
             "kind": "request",
             "parts": [
-                {
-                    "content": "You are a helpful test assistant :)",
-                    "dynamic_ref": None,
-                    "part_kind": "system-prompt",
-                    "timestamp": "2025-07-25T10:36:35.297675Z",
-                },
-                {
-                    "content": "Today is Friday 25/07/2025.",
-                    "dynamic_ref": None,
-                    "part_kind": "system-prompt",
-                    "timestamp": "2025-07-25T10:36:35.297675Z",
-                },
-                {
-                    "content": "Answer in french.",
-                    "dynamic_ref": None,
-                    "part_kind": "system-prompt",
-                    "timestamp": "2025-07-25T10:36:35.297675Z",
-                },
                 {
                     "content": ["Weather in Paris?"],
                     "part_kind": "user-prompt",
                     "timestamp": "2025-07-25T10:36:35.297675Z",
                 },
             ],
+            "run_id": _run_id,
         },
         {
             "finish_reason": "tool_call",
@@ -931,9 +899,13 @@ def test_post_conversation_tool_call_fails(api_client, mock_openai_stream_tool,
                 "output_audio_tokens": 0,
                 "output_tokens": 0,
             },
+            "run_id": _run_id,
         },
         {
-            "instructions": None,
+            "instructions": (
+                "You are a helpful test assistant :)\n\n"
+                "Today is Friday 25/07/2025.\n\nAnswer in french."
+            ),
             "kind": "request",
             "parts": [
                 {
@@ -944,6 +916,7 @@ def test_post_conversation_tool_call_fails(api_client, mock_openai_stream_tool,
                     "tool_name": "get_current_weather",
                 }
             ],
+            "run_id": _run_id,
         },
         {
             "finish_reason": "stop",
@@ -966,6 +939,7 @@ def test_post_conversation_tool_call_fails(api_client, mock_openai_stream_tool,
                 "output_audio_tokens": 0,
                 "output_tokens": 0,
             },
+            "run_id": _run_id,
         },
     ]
 
@@ -1192,35 +1166,21 @@ def test_post_conversation_data_protocol_no_stream(
         ],
     )
 
+    _run_id = chat_conversation.pydantic_messages[0]["run_id"]
     assert chat_conversation.pydantic_messages == [
         {
-            "instructions": None,
+            "instructions": (
+                "You are an amazing assistant.\n\nToday is Friday 25/07/2025.\n\nAnswer in english."
+            ),
             "kind": "request",
             "parts": [
-                {
-                    "content": "You are an amazing assistant.",
-                    "dynamic_ref": None,
-                    "part_kind": "system-prompt",
-                    "timestamp": "2025-07-25T10:36:35.297675Z",
-                },
-                {
-                    "content": "Today is Friday 25/07/2025.",
-                    "dynamic_ref": None,
-                    "part_kind": "system-prompt",
-                    "timestamp": "2025-07-25T10:36:35.297675Z",
-                },
-                {
-                    "content": "Answer in english.",
-                    "dynamic_ref": None,
-                    "part_kind": "system-prompt",
-                    "timestamp": "2025-07-25T10:36:35.297675Z",
-                },
                 {
                     "content": ["Why the sky is blue?"],
                     "part_kind": "user-prompt",
                     "timestamp": "2025-07-25T10:36:35.297675Z",
                 },
             ],
+            "run_id": _run_id,
         },
         {
             "finish_reason": "stop",
@@ -1248,6 +1208,7 @@ def test_post_conversation_data_protocol_no_stream(
                 "output_audio_tokens": 0,
                 "output_tokens": 135,
             },
+            "run_id": _run_id,
         },
     ]
 
@@ -1344,35 +1305,22 @@ async def test_post_conversation_async(api_client, mock_openai_stream, monkeypat
         parts=[TextUIPart(type="text", text="Hello there")],
     )
 
+    _run_id = chat_conversation.pydantic_messages[0]["run_id"]
     assert chat_conversation.pydantic_messages == [
         {
-            "instructions": None,
+            "instructions": (
+                "You are a helpful test assistant :)\n\n"
+                "Today is Friday 25/07/2025.\n\nAnswer in english."
+            ),
             "kind": "request",
             "parts": [
-                {
-                    "content": "You are a helpful test assistant :)",
-                    "dynamic_ref": None,
-                    "part_kind": "system-prompt",
-                    "timestamp": "2025-07-25T10:36:35.297675Z",
-                },
-                {
-                    "content": "Today is Friday 25/07/2025.",
-                    "dynamic_ref": None,
-                    "part_kind": "system-prompt",
-                    "timestamp": "2025-07-25T10:36:35.297675Z",
-                },
-                {
-                    "content": "Answer in english.",
-                    "dynamic_ref": None,
-                    "part_kind": "system-prompt",
-                    "timestamp": "2025-07-25T10:36:35.297675Z",
-                },
                 {
                     "content": ["Hello"],
                     "part_kind": "user-prompt",
                     "timestamp": "2025-07-25T10:36:35.297675Z",
                 },
             ],
+            "run_id": _run_id,
         },
         {
             "finish_reason": "stop",
@@ -1393,5 +1341,6 @@ async def test_post_conversation_async(api_client, mock_openai_stream, monkeypat
                 "output_audio_tokens": 0,
                 "output_tokens": 0,
             },
+            "run_id": _run_id,
         },
     ]

src/backend/chat/tests/views/chat/conversations/test_conversation_with_document_upload.py

@@ -216,7 +216,8 @@ def fixture_mock_openai_stream():
 @responses.activate
 @respx.mock
 @freeze_time()
-def test_post_conversation_with_document_upload(  # pylint: disable=too-many-arguments,too-many-positional-arguments
+def test_post_conversation_with_document_upload(
+    # pylint: disable=too-many-arguments,too-many-positional-arguments
     api_client,
     mock_albert_api,  # pylint: disable=unused-argument
     sample_pdf_content,
@@ -351,59 +352,34 @@ def test_post_conversation_with_document_upload(  # pylint: disable=too-many-arg
     _formatted_date = formats.date_format(timezone.now(), "l d/m/Y", use_l10n=False)
 
     assert len(chat_conversation.pydantic_messages) == 4
+
+    _run_id = chat_conversation.pydantic_messages[0]["run_id"]
+
     assert chat_conversation.pydantic_messages[0] == {
-        "instructions": "When you receive a result from the summarization tool, you "
-        "MUST return it directly to the user without any "
-        "modification, paraphrasing, or additional summarization.The "
-        "tool already produces optimized summaries that should be "
-        "presented verbatim.You may translate the summary if "
-        "required, but you MUST preserve all the information from the "
-        "original summary.You may add a follow-up question after the "
-        "summary if needed.",
+        "instructions": "You are a helpful test assistant :)\n\n"
+        f"{today_promt_date}\n\n"
+        "Answer in english.\n\n"
+        "Use document_search_rag ONLY to retrieve specific passages from "
+        "attached documents. Do NOT use it to summarize; for summaries, "
+        "call the summarize tool instead.\n\nWhen you receive a result from the "
+        "summarization tool, you MUST return it directly to the user without "
+        "any modification, paraphrasing, or additional summarization."
+        "The tool already produces optimized summaries that should be "
+        "presented verbatim.You may translate the summary if required, "
+        "but you MUST preserve all the information from the original summary."
+        "You may add a follow-up question after the summary if needed.\n\n"
+        "[Internal context] User documents are attached to this conversation. "
+        "Do not request re-upload of documents; consider them already "
+        "available via the internal store.",
         "kind": "request",
         "parts": [
-            {
-                "content": "You are a helpful test assistant :)",
-                "dynamic_ref": None,
-                "part_kind": "system-prompt",
-                "timestamp": timezone_now,
-            },
-            {
-                "content": today_promt_date,
-                "dynamic_ref": None,
-                "part_kind": "system-prompt",
-                "timestamp": timezone_now,
-            },
-            {
-                "content": "Answer in english.",
-                "dynamic_ref": None,
-                "part_kind": "system-prompt",
-                "timestamp": timezone_now,
-            },
-            {
-                "content": "Use document_search_rag ONLY to retrieve specific "
-                "passages from attached documents. Do NOT use it to "
-                "summarize; for summaries, call the summarize tool "
-                "instead.",
-                "dynamic_ref": None,
-                "part_kind": "system-prompt",
-                "timestamp": timezone_now,
-            },
-            {
-                "content": "[Internal context] User documents are attached to this "
-                "conversation. Do not request re-upload of documents; "
-                "consider them already available via the internal "
-                "store.",
-                "dynamic_ref": None,
-                "part_kind": "system-prompt",
-                "timestamp": timezone_now,
-            },
             {
                 "content": ["What does the document say?"],
                 "part_kind": "user-prompt",
                 "timestamp": timezone_now,
             },
         ],
+        "run_id": _run_id,
     }
     assert chat_conversation.pydantic_messages[1] == {
         "finish_reason": None,
@@ -432,17 +408,25 @@ def test_post_conversation_with_document_upload(  # pylint: disable=too-many-arg
             "output_audio_tokens": 0,
             "output_tokens": 8,
         },
+        "run_id": _run_id,
     }
     assert chat_conversation.pydantic_messages[2] == {
         "instructions": (
-            "When you receive a result from the summarization tool, you MUST "
-            "return it directly to the user without any modification, "
-            "paraphrasing, or additional summarization."
-            "The tool already produces optimized summaries that should "
-            "be presented verbatim."
-            "You may translate the summary if required, but you MUST preserve "
-            "all the information from the original summary."
-            "You may add a follow-up question after the summary if needed."
+            "You are a helpful test assistant :)\n\n"
+            f"{today_promt_date}\n\n"
+            "Answer in english.\n\n"
+            "Use document_search_rag ONLY to retrieve specific passages from "
+            "attached documents. Do NOT use it to summarize; for summaries, "
+            "call the summarize tool instead.\n\nWhen you receive a result from the "
+            "summarization tool, you MUST return it directly to the user without "
+            "any modification, paraphrasing, or additional summarization."
+            "The tool already produces optimized summaries that should be "
+            "presented verbatim.You may translate the summary if required, "
+            "but you MUST preserve all the information from the original summary."
+            "You may add a follow-up question after the summary if needed.\n\n"
+            "[Internal context] User documents are attached to this conversation. "
+            "Do not request re-upload of documents; consider them already "
+            "available via the internal store."
         ),
         "kind": "request",
         "parts": [
@@ -461,6 +445,7 @@ def test_post_conversation_with_document_upload(  # pylint: disable=too-many-arg
                 "tool_name": "document_search_rag",
             }
         ],
+        "run_id": _run_id,
     }
     assert chat_conversation.pydantic_messages[3] == {
         "finish_reason": None,
@@ -487,13 +472,15 @@ def test_post_conversation_with_document_upload(  # pylint: disable=too-many-arg
             "output_audio_tokens": 0,
             "output_tokens": 12,
         },
+        "run_id": _run_id,
     }
 
 
 @responses.activate
 @respx.mock
 @freeze_time("2025-07-25T10:36:35.297675Z")
-def test_post_conversation_with_document_upload_feature_disabled(  # pylint: disable=too-many-arguments,too-many-positional-arguments
+def test_post_conversation_with_document_upload_feature_disabled(
+    # pylint: disable=too-many-arguments,too-many-positional-arguments
     api_client,
     caplog,
     mock_openai_stream,  # pylint: disable=unused-argument
@@ -546,14 +533,12 @@ def test_post_conversation_with_document_upload_feature_disabled(  # pylint: dis
 
     # Replace UUIDs with placeholders for assertion
     response_content = replace_uuids_with_placeholder(response_content)
-
     assert response_content == (
         '0:"From the document, I can see that "\n'
         "0:\"it says 'Hello PDF'.\"\n"
         'f:{"messageId":"<mocked_uuid>"}\n'
         'd:{"finishReason":"stop","usage":{"promptTokens":150,"completionTokens":25}}\n'
     )
-
     # This behavior must be improved in the future to inform the user properly
     assert "Document upload feature is disabled, ignoring input documents." in caplog.text
 
@@ -576,6 +561,7 @@ def test_post_conversation_with_document_upload_summarize(  # pylint: disable=to
     api_client.force_authenticate(user=chat_conversation.owner)
 
     pdf_base64 = base64.b64encode(sample_pdf_content.read()).decode("utf-8")
+
     message = UIMessage(
         id="1",
         role="user",
@@ -637,7 +623,7 @@ def test_post_conversation_with_document_upload_summarize(  # pylint: disable=to
         'document discusses various topics."}\n'
         '0:"The document discusses various topics."\n'
         'f:{"messageId":"<mocked_uuid>"}\n'
-        'd:{"finishReason":"stop","usage":{"promptTokens":317,"completionTokens":19}}\n'
+        'd:{"finishReason":"stop","usage":{"promptTokens":287,"completionTokens":19}}\n'
     )
 
     # Check that the conversation was updated
@@ -696,59 +682,35 @@ def test_post_conversation_with_document_upload_summarize(  # pylint: disable=to
     _formatted_date = formats.date_format(timezone.now(), "l d/m/Y", use_l10n=False)
 
     assert len(chat_conversation.pydantic_messages) == 4
+
+    _run_id = chat_conversation.pydantic_messages[0]["run_id"]
     assert chat_conversation.pydantic_messages[0] == {
-        "instructions": "When you receive a result from the summarization tool, you "
-        "MUST return it directly to the user without any "
-        "modification, paraphrasing, or additional summarization.The "
-        "tool already produces optimized summaries that should be "
-        "presented verbatim.You may translate the summary if "
-        "required, but you MUST preserve all the information from the "
-        "original summary.You may add a follow-up question after the "
-        "summary if needed.",
+        "instructions": (
+            "You are a helpful test assistant :)\n\n"
+            f"{today_promt_date}\n\n"
+            "Answer in english.\n\n"
+            "Use document_search_rag ONLY to retrieve specific passages from "
+            "attached documents. Do NOT use it to summarize; for summaries, "
+            "call the summarize tool instead.\n\nWhen you receive a result from the "
+            "summarization tool, you MUST return it directly to the user without "
+            "any modification, paraphrasing, or additional summarization."
+            "The tool already produces optimized summaries that should be "
+            "presented verbatim.You may translate the summary if required, "
+            "but you MUST preserve all the information from the original summary."
+            "You may add a follow-up question after the summary if needed.\n\n"
+            "[Internal context] User documents are attached to this conversation. "
+            "Do not request re-upload of documents; consider them already "
+            "available via the internal store."
+        ),
         "kind": "request",
         "parts": [
-            {
-                "content": "You are a helpful test assistant :)",
-                "dynamic_ref": None,
-                "part_kind": "system-prompt",
-                "timestamp": timezone_now,
-            },
-            {
-                "content": today_promt_date,
-                "dynamic_ref": None,
-                "part_kind": "system-prompt",
-                "timestamp": timezone_now,
-            },
-            {
-                "content": "Answer in english.",
-                "dynamic_ref": None,
-                "part_kind": "system-prompt",
-                "timestamp": timezone_now,
-            },
-            {
-                "content": "Use document_search_rag ONLY to retrieve specific "
-                "passages from attached documents. Do NOT use it to "
-                "summarize; for summaries, call the summarize tool "
-                "instead.",
-                "dynamic_ref": None,
-                "part_kind": "system-prompt",
-                "timestamp": timezone_now,
-            },
-            {
-                "content": "[Internal context] User documents are attached to this "
-                "conversation. Do not request re-upload of documents; "
-                "consider them already available via the internal "
-                "store.",
-                "dynamic_ref": None,
-                "part_kind": "system-prompt",
-                "timestamp": timezone_now,
-            },
             {
                 "content": ["Make a summary of this document."],
                 "part_kind": "user-prompt",
                 "timestamp": timezone_now,
             },
         ],
+        "run_id": _run_id,
     }
     assert chat_conversation.pydantic_messages[1] == {
         "finish_reason": None,
@@ -777,17 +739,25 @@ def test_post_conversation_with_document_upload_summarize(  # pylint: disable=to
             "output_audio_tokens": 0,
             "output_tokens": 1,
         },
+        "run_id": _run_id,
     }
     assert chat_conversation.pydantic_messages[2] == {
         "instructions": (
-            "When you receive a result from the summarization tool, you MUST "
-            "return it directly to the user without any modification, "
-            "paraphrasing, or additional summarization."
-            "The tool already produces optimized summaries that should "
-            "be presented verbatim."
-            "You may translate the summary if required, but you MUST preserve "
-            "all the information from the original summary."
-            "You may add a follow-up question after the summary if needed."
+            "You are a helpful test assistant :)\n\n"
+            f"{today_promt_date}\n\n"
+            "Answer in english.\n\n"
+            "Use document_search_rag ONLY to retrieve specific passages from "
+            "attached documents. Do NOT use it to summarize; for summaries, "
+            "call the summarize tool instead.\n\nWhen you receive a result from the "
+            "summarization tool, you MUST return it directly to the user without "
+            "any modification, paraphrasing, or additional summarization."
+            "The tool already produces optimized summaries that should be "
+            "presented verbatim.You may translate the summary if required, "
+            "but you MUST preserve all the information from the original summary."
+            "You may add a follow-up question after the summary if needed.\n\n"
+            "[Internal context] User documents are attached to this conversation. "
+            "Do not request re-upload of documents; consider them already "
+            "available via the internal store."
         ),
         "kind": "request",
         "parts": [
@@ -800,6 +770,7 @@ def test_post_conversation_with_document_upload_summarize(  # pylint: disable=to
                 "tool_name": "summarize",
             }
         ],
+        "run_id": _run_id,
     }
     assert chat_conversation.pydantic_messages[3] == {
         "finish_reason": None,
@@ -822,4 +793,5 @@ def test_post_conversation_with_document_upload_summarize(  # pylint: disable=to
             "output_audio_tokens": 0,
             "output_tokens": 6,
         },
+        "run_id": _run_id,
     }

src/backend/chat/tests/views/chat/conversations/test_conversation_with_document_url.py

@@ -17,7 +17,6 @@ from pydantic_ai.messages import (
     DocumentUrl,
     ModelMessage,
     ModelResponse,
-    SystemPromptPart,
     TextPart,
     UserPromptPart,
 )
@@ -61,7 +60,8 @@ def fixture_sample_document_content():
 
 @responses.activate
 @freeze_time()
-def test_post_conversation_with_local_pdf_document_url(  # pylint: disable=too-many-arguments,too-many-positional-arguments
+def test_post_conversation_with_local_pdf_document_url(
+    # pylint: disable=too-many-arguments,too-many-positional-arguments
     api_client,
     sample_document_content,
     today_promt_date,
@@ -120,7 +120,7 @@ def test_post_conversation_with_local_pdf_document_url(  # pylint: disable=too-m
     )
 
     async def agent_model(messages: list[ModelMessage], _info: AgentInfo):
-        presigned_url = messages[0].parts[3].content[1].url
+        presigned_url = messages[0].parts[0].content[1].url
         assert presigned_url.startswith("http://localhost:9000/conversations-media-storage/")
         assert presigned_url.find("X-Amz-Signature=") != -1
         assert presigned_url.find("X-Amz-Date=") != -1
@@ -129,11 +129,6 @@ def test_post_conversation_with_local_pdf_document_url(  # pylint: disable=too-m
         assert messages == [
             ModelRequest(
                 parts=[
-                    SystemPromptPart(
-                        content="You are a helpful test assistant :)", timestamp=timezone.now()
-                    ),
-                    SystemPromptPart(content=today_promt_date, timestamp=timezone.now()),
-                    SystemPromptPart(content="Answer in english.", timestamp=timezone.now()),
                     UserPromptPart(
                         content=[
                             "What is in this document?",
@@ -145,7 +140,10 @@ def test_post_conversation_with_local_pdf_document_url(  # pylint: disable=too-m
                         ],
                         timestamp=timezone.now(),
                     ),
-                ]
+                ],
+                instructions=f"You are a helpful test assistant :)\n\n{today_promt_date}"
+                "\n\nAnswer in english.",
+                run_id=messages[0].run_id,
             )
         ]
         yield "This is a document about a single pixel."
@@ -217,29 +215,14 @@ def test_post_conversation_with_local_pdf_document_url(  # pylint: disable=too-m
     timestamp = timezone.now().strftime("%Y-%m-%dT%H:%M:%S.%fZ")
     _formatted_date = formats.date_format(timezone.now(), "l d/m/Y", use_l10n=False)
 
+    _run_id = chat_conversation.pydantic_messages[0]["run_id"]
     assert chat_conversation.pydantic_messages == [
         {
-            "instructions": None,
+            "instructions": "You are a helpful test assistant :)\n\n"
+            f"{today_promt_date}\n\n"
+            "Answer in english.",
             "kind": "request",
             "parts": [
-                {
-                    "content": "You are a helpful test assistant :)",
-                    "dynamic_ref": None,
-                    "part_kind": "system-prompt",
-                    "timestamp": timestamp,
-                },
-                {
-                    "content": today_promt_date,
-                    "dynamic_ref": None,
-                    "part_kind": "system-prompt",
-                    "timestamp": timestamp,
-                },
-                {
-                    "content": "Answer in english.",
-                    "dynamic_ref": None,
-                    "part_kind": "system-prompt",
-                    "timestamp": timestamp,
-                },
                 {
                     "content": [
                         "What is in this document?",
@@ -256,6 +239,7 @@ def test_post_conversation_with_local_pdf_document_url(  # pylint: disable=too-m
                     "timestamp": timestamp,
                 },
             ],
+            "run_id": _run_id,
         },
         {
             "finish_reason": None,
@@ -282,6 +266,7 @@ def test_post_conversation_with_local_pdf_document_url(  # pylint: disable=too-m
                 "output_audio_tokens": 0,
                 "output_tokens": 9,
             },
+            "run_id": _run_id,
         },
     ]
 
@@ -425,7 +410,6 @@ def test_post_conversation_with_remote_document_url(
 @freeze_time("2025-10-18T20:48:20.286204Z")
 def test_post_conversation_with_local_document_url_in_history(  # pylint: disable=too-many-arguments,too-many-positional-arguments
     api_client,
-    today_promt_date,
     mock_ai_agent_service,
 ):
     """
@@ -433,6 +417,8 @@ def test_post_conversation_with_local_document_url_in_history(  # pylint: disabl
     """
     chat_conversation_pk = "0be55da5-8eb7-4dad-aa0f-fea454bd5809"
     document_url = f"/media-key/{chat_conversation_pk}/sample.pdf"
+    formatted_date = formats.date_format(timezone.now(), "l d/m/Y", use_l10n=False)
+
     chat_conversation = ChatConversationFactory(
         pk=chat_conversation_pk,
         owner__language="en-us",
@@ -468,27 +454,11 @@ def test_post_conversation_with_local_document_url_in_history(  # pylint: disabl
         ],
         pydantic_messages=[
             {
-                "instructions": None,
+                "instructions": "You are a helpful test assistant :)\n\n"
+                f"Today is {formatted_date}.\n\n"
+                "Answer in english.",
                 "kind": "request",
                 "parts": [
-                    {
-                        "content": "You are a helpful test assistant :)",
-                        "dynamic_ref": None,
-                        "part_kind": "system-prompt",
-                        "timestamp": "2025-10-18T20:48:20.286204Z",
-                    },
-                    {
-                        "content": today_promt_date,
-                        "dynamic_ref": None,
-                        "part_kind": "system-prompt",
-                        "timestamp": "2025-10-18T20:48:20.286204Z",
-                    },
-                    {
-                        "content": "Answer in english.",
-                        "dynamic_ref": None,
-                        "part_kind": "system-prompt",
-                        "timestamp": "2025-10-18T20:48:20.286204Z",
-                    },
                     {
                         "content": [
                             "What is in this document?",
@@ -551,7 +521,7 @@ def test_post_conversation_with_local_document_url_in_history(  # pylint: disabl
     )
 
     async def agent_model(messages: list[ModelMessage], _info: AgentInfo):
-        presigned_url = messages[0].parts[3].content[1].url
+        presigned_url = messages[0].parts[0].content[1].url
         assert presigned_url.startswith("http://localhost:9000/conversations-media-storage/")
         assert presigned_url.find("X-Amz-Signature=") != -1
         assert presigned_url.find("X-Amz-Date=") != -1
@@ -560,18 +530,6 @@ def test_post_conversation_with_local_document_url_in_history(  # pylint: disabl
         assert messages == [
             ModelRequest(
                 parts=[
-                    SystemPromptPart(
-                        content="You are a helpful test assistant :)",
-                        timestamp=timezone.now(),
-                    ),
-                    SystemPromptPart(
-                        content=today_promt_date,
-                        timestamp=timezone.now(),
-                    ),
-                    SystemPromptPart(
-                        content="Answer in english.",
-                        timestamp=timezone.now(),
-                    ),
                     UserPromptPart(
                         content=[
                             "What is in this document?",
@@ -583,13 +541,18 @@ def test_post_conversation_with_local_document_url_in_history(  # pylint: disabl
                         ],
                         timestamp=timezone.now(),
                     ),
-                ]
+                ],
+                instructions="You are a helpful test assistant :)\n\n"
+                "Today is Saturday 18/10/2025.\n\n"
+                "Answer in english.",
+                run_id=messages[0].run_id,
             ),
             ModelResponse(
                 parts=[TextPart(content="This is a document about a single pixel.")],
                 usage=RequestUsage(input_tokens=50, output_tokens=9),
                 model_name="function::agent_model",
                 timestamp=timezone.now(),
+                run_id=messages[1].run_id,
             ),
             ModelRequest(
                 parts=[
@@ -599,7 +562,11 @@ def test_post_conversation_with_local_document_url_in_history(  # pylint: disabl
                         ],
                         timestamp=timezone.now(),
                     )
-                ]
+                ],
+                instructions="You are a helpful test assistant :)\n\n"
+                "Today is Saturday 18/10/2025.\n\n"
+                "Answer in english.",
+                run_id=messages[2].run_id,
             ),
         ]
         yield "This is a document of square, very small and nice."
@@ -695,29 +662,14 @@ def test_post_conversation_with_local_document_url_in_history(  # pylint: disabl
         ],
     )
 
+    _run_id = chat_conversation.pydantic_messages[2]["run_id"]
     assert chat_conversation.pydantic_messages == [
         {
-            "instructions": None,
+            "instructions": "You are a helpful test assistant :)\n\n"
+            "Today is Saturday 18/10/2025.\n\n"
+            "Answer in english.",
             "kind": "request",
             "parts": [
-                {
-                    "content": "You are a helpful test assistant :)",
-                    "dynamic_ref": None,
-                    "part_kind": "system-prompt",
-                    "timestamp": "2025-10-18T20:48:20.286204Z",
-                },
-                {
-                    "content": today_promt_date,
-                    "dynamic_ref": None,
-                    "part_kind": "system-prompt",
-                    "timestamp": "2025-10-18T20:48:20.286204Z",
-                },
-                {
-                    "content": "Answer in english.",
-                    "dynamic_ref": None,
-                    "part_kind": "system-prompt",
-                    "timestamp": "2025-10-18T20:48:20.286204Z",
-                },
                 {
                     "content": [
                         "What is in this document?",
@@ -734,6 +686,7 @@ def test_post_conversation_with_local_document_url_in_history(  # pylint: disabl
                     "timestamp": "2025-10-18T20:48:20.286204Z",
                 },
             ],
+            # no run_id here
         },
         {
             "finish_reason": None,
@@ -760,9 +713,12 @@ def test_post_conversation_with_local_document_url_in_history(  # pylint: disabl
                 "output_audio_tokens": 0,
                 "output_tokens": 9,
             },
+            # no run_id here
         },
         {
-            "instructions": None,
+            "instructions": "You are a helpful test assistant :)\n\n"
+            "Today is Saturday 18/10/2025.\n\n"
+            "Answer in english.",
             "kind": "request",
             "parts": [
                 {
@@ -771,6 +727,7 @@ def test_post_conversation_with_local_document_url_in_history(  # pylint: disabl
                     "timestamp": "2025-10-18T20:48:20.286204Z",
                 }
             ],
+            "run_id": _run_id,
         },
         {
             "finish_reason": None,
@@ -797,6 +754,7 @@ def test_post_conversation_with_local_document_url_in_history(  # pylint: disabl
                 "output_audio_tokens": 0,
                 "output_tokens": 11,
             },
+            "run_id": _run_id,
         },
     ]
 
@@ -811,7 +769,8 @@ def test_post_conversation_with_local_document_url_in_history(  # pylint: disabl
         ("data.csv", "text/csv"),
     ],
 )
-def test_post_conversation_with_local_not_pdf_document_url(  # pylint: disable=too-many-arguments,too-many-positional-arguments
+def test_post_conversation_with_local_not_pdf_document_url(
+    # pylint: disable=too-many-arguments,too-many-positional-arguments
     api_client,
     today_promt_date,
     mock_ai_agent_service,
@@ -874,27 +833,6 @@ def test_post_conversation_with_local_not_pdf_document_url(  # pylint: disable=t
         assert messages == [
             ModelRequest(
                 parts=[
-                    SystemPromptPart(
-                        content="You are a helpful test assistant :)", timestamp=timezone.now()
-                    ),
-                    SystemPromptPart(content=today_promt_date, timestamp=timezone.now()),
-                    SystemPromptPart(content="Answer in english.", timestamp=timezone.now()),
-                    SystemPromptPart(
-                        content=(
-                            "Use document_search_rag ONLY to retrieve specific passages from "
-                            "attached documents. Do NOT use it to summarize; for summaries, "
-                            "call the summarize tool instead."
-                        ),
-                        timestamp=timezone.now(),
-                    ),
-                    SystemPromptPart(
-                        content=(
-                            "[Internal context] User documents are attached to this conversation. "
-                            "Do not request re-upload of documents; consider them already "
-                            "available via the internal store."
-                        ),
-                        timestamp=timezone.now(),
-                    ),
                     UserPromptPart(
                         content=[
                             "What is in this document?",
@@ -904,15 +842,24 @@ def test_post_conversation_with_local_not_pdf_document_url(  # pylint: disable=t
                     ),
                 ],
                 instructions=(
-                    "When you receive a result from the summarization tool, you MUST "
-                    "return it directly to the user without any modification, "
-                    "paraphrasing, or additional summarization."
-                    "The tool already produces optimized summaries that should "
-                    "be presented verbatim."
-                    "You may translate the summary if required, but you MUST preserve "
-                    "all the information from the original summary."
-                    "You may add a follow-up question after the summary if needed."
+                    "You are a helpful test assistant :)\n\n"
+                    f"{today_promt_date}\n\n"
+                    "Answer in english.\n\n"
+                    "Use document_search_rag ONLY to retrieve specific passages from "
+                    "attached documents. Do NOT use it to summarize; for summaries, "
+                    "call the summarize tool instead.\n\nWhen you receive a result "
+                    "from the summarization tool, you MUST return it directly to "
+                    "the user without any modification, paraphrasing, or additional "
+                    "summarization.The tool already produces optimized summaries "
+                    "that should be presented verbatim.You may translate the summary "
+                    "if required, but you MUST preserve all the information from the "
+                    "original summary.You may add a follow-up question after the "
+                    "summary if needed.\n\n"
+                    "[Internal context] User documents are attached to this conversation. "
+                    "Do not request re-upload of documents; "
+                    "consider them already available via the internal store."
                 ),
+                run_id=messages[0].run_id,
             )
         ]
         yield "This is a document about you."
@@ -982,56 +929,29 @@ def test_post_conversation_with_local_not_pdf_document_url(  # pylint: disable=t
     timestamp = timezone.now().strftime("%Y-%m-%dT%H:%M:%S.%fZ")
     _formatted_date = formats.date_format(timezone.now(), "l d/m/Y", use_l10n=False)
 
+    _run_id = chat_conversation.pydantic_messages[0]["run_id"]
     assert chat_conversation.pydantic_messages == [
         {
             "instructions": (
-                "When you receive a result from the summarization tool, you MUST "
-                "return it directly to the user without any modification, "
-                "paraphrasing, or additional summarization."
-                "The tool already produces optimized summaries that should "
-                "be presented verbatim."
-                "You may translate the summary if required, but you MUST preserve "
-                "all the information from the original summary."
-                "You may add a follow-up question after the summary if needed."
+                "You are a helpful test assistant :)\n\n"
+                f"{today_promt_date}\n\n"
+                "Answer in english.\n\n"
+                "Use document_search_rag ONLY to retrieve specific passages from "
+                "attached documents. Do NOT use it to summarize; for summaries, "
+                "call the summarize tool instead.\n\nWhen you receive a result "
+                "from the summarization tool, you MUST return it directly to "
+                "the user without any modification, paraphrasing, or additional "
+                "summarization.The tool already produces optimized summaries "
+                "that should be presented verbatim.You may translate the summary "
+                "if required, but you MUST preserve all the information from the "
+                "original summary.You may add a follow-up question after the "
+                "summary if needed.\n\n"
+                "[Internal context] User documents are attached to this conversation. "
+                "Do not request re-upload of documents; "
+                "consider them already available via the internal store."
             ),
             "kind": "request",
             "parts": [
-                {
-                    "content": "You are a helpful test assistant :)",
-                    "dynamic_ref": None,
-                    "part_kind": "system-prompt",
-                    "timestamp": timestamp,
-                },
-                {
-                    "content": today_promt_date,
-                    "dynamic_ref": None,
-                    "part_kind": "system-prompt",
-                    "timestamp": timestamp,
-                },
-                {
-                    "content": "Answer in english.",
-                    "dynamic_ref": None,
-                    "part_kind": "system-prompt",
-                    "timestamp": timestamp,
-                },
-                {
-                    "content": "Use document_search_rag ONLY to retrieve specific "
-                    "passages from attached documents. Do NOT use it to "
-                    "summarize; for summaries, call the summarize tool "
-                    "instead.",
-                    "dynamic_ref": None,
-                    "part_kind": "system-prompt",
-                    "timestamp": timestamp,
-                },
-                {
-                    "content": "[Internal context] User documents are attached to "
-                    "this conversation. Do not request re-upload of "
-                    "documents; consider them already available via the "
-                    "internal store.",
-                    "dynamic_ref": None,
-                    "part_kind": "system-prompt",
-                    "timestamp": timestamp,
-                },
                 {
                     "content": [
                         "What is in this document?",
@@ -1040,6 +960,7 @@ def test_post_conversation_with_local_not_pdf_document_url(  # pylint: disable=t
                     "timestamp": timestamp,
                 },
             ],
+            "run_id": _run_id,
         },
         {
             "finish_reason": None,
@@ -1066,5 +987,6 @@ def test_post_conversation_with_local_not_pdf_document_url(  # pylint: disable=t
                 "output_audio_tokens": 0,
                 "output_tokens": 7,
             },
+            "run_id": _run_id,
         },
     ]

src/backend/chat/tests/views/chat/conversations/test_conversation_with_history.py

@@ -919,7 +919,7 @@ def history_conversation_with_tool_fixture():
     history_timestamp = timezone.now().replace(year=2025, month=6, day=15, hour=10, minute=30)
 
     # Create a conversation with pre-existing messages including a tool invocation
-    conversation = ChatConversationFactory()
+    conversation = ChatConversationFactory(owner__language="nl-nl")
 
     # Add previous user and assistant messages with tool invocation
     conversation.messages = [
@@ -1373,9 +1373,13 @@ def test_post_conversation_with_existing_tool_history(
     # The pydantic_messages should include both the original tool calls and the new ones
     assert len(history_conversation_with_tool.pydantic_messages) == 12  # Original 8 + 4 new ones
 
+    _run_id = history_conversation_with_tool.pydantic_messages[8]["run_id"]
+
     # Verify the new tool call request is included
     assert history_conversation_with_tool.pydantic_messages[8] == {
-        "instructions": None,
+        "instructions": "You are a helpful test assistant :)\n\n"
+        "Today is Friday 25/07/2025.\n\n"
+        "Answer in dutch.",
         "kind": "request",
         "parts": [
             {
@@ -1384,6 +1388,7 @@ def test_post_conversation_with_existing_tool_history(
                 "timestamp": "2025-07-25T10:36:35.297675Z",
             }
         ],
+        "run_id": _run_id,
     }
 
     assert history_conversation_with_tool.pydantic_messages[9] == {
@@ -1413,10 +1418,13 @@ def test_post_conversation_with_existing_tool_history(
             "output_audio_tokens": 0,
             "output_tokens": 0,
         },
+        "run_id": _run_id,
     }
 
     assert history_conversation_with_tool.pydantic_messages[10] == {
-        "instructions": None,
+        "instructions": "You are a helpful test assistant :)\n\n"
+        "Today is Friday 25/07/2025.\n\n"
+        "Answer in dutch.",
         "kind": "request",
         "parts": [
             {
@@ -1428,6 +1436,7 @@ def test_post_conversation_with_existing_tool_history(
                 "tool_name": "get_current_weather",
             }
         ],
+        "run_id": _run_id,
     }
 
     assert history_conversation_with_tool.pydantic_messages[11] == {
@@ -1451,6 +1460,7 @@ def test_post_conversation_with_existing_tool_history(
             "output_audio_tokens": 0,
             "output_tokens": 0,
         },
+        "run_id": _run_id,
     }
 
 

src/backend/chat/tests/views/chat/conversations/test_conversation_with_image_url.py

@@ -2,7 +2,7 @@
 
 import uuid
 
-from django.utils import timezone
+from django.utils import formats, timezone
 
 import pytest
 from dirty_equals import IsUUID
@@ -12,7 +12,6 @@ from pydantic_ai.messages import (
     ImageUrl,
     ModelMessage,
     ModelResponse,
-    SystemPromptPart,
     TextPart,
     UserPromptPart,
 )
@@ -87,22 +86,15 @@ def test_post_conversation_with_local_image_url(
     )
 
     async def agent_model(messages: list[ModelMessage], _info: AgentInfo):
-        presigned_url = messages[0].parts[3].content[1].url
-        assert presigned_url.startswith("http://localhost:9000/conversations-media-storage/")
+        presigned_url = messages[0].parts[0].content[1].url
+        # assert presigned_url.startswith("http://localhost:9000/conversations-media-storage/")
         assert presigned_url.find("X-Amz-Signature=") != -1
         assert presigned_url.find("X-Amz-Date=") != -1
         assert presigned_url.find("X-Amz-Expires=") != -1
-
+        formatted_date = formats.date_format(timezone.now(), "l d/m/Y", use_l10n=False)
         assert messages == [
             ModelRequest(
                 parts=[
-                    SystemPromptPart(
-                        content="You are a helpful test assistant :)", timestamp=timezone.now()
-                    ),
-                    SystemPromptPart(
-                        content="Today is Saturday 18/10/2025.", timestamp=timezone.now()
-                    ),
-                    SystemPromptPart(content="Answer in english.", timestamp=timezone.now()),
                     UserPromptPart(
                         content=[
                             "What is in this image?",
@@ -114,7 +106,10 @@ def test_post_conversation_with_local_image_url(
                         ],
                         timestamp=timezone.now(),
                     ),
-                ]
+                ],
+                instructions="You are a helpful test assistant :)\n\nToday is "
+                f"{formatted_date}.\n\nAnswer in english.",
+                run_id=messages[0].run_id,
             )
         ]
         yield "This is an image of a single pixel."
@@ -180,29 +175,13 @@ def test_post_conversation_with_local_image_url(
         ],
     )
 
+    _run_id = chat_conversation.pydantic_messages[0]["run_id"]
     assert chat_conversation.pydantic_messages == [
         {
-            "instructions": None,
+            "instructions": "You are a helpful test assistant :)\n\n"
+            "Today is Saturday 18/10/2025.\n\nAnswer in english.",
             "kind": "request",
             "parts": [
-                {
-                    "content": "You are a helpful test assistant :)",
-                    "dynamic_ref": None,
-                    "part_kind": "system-prompt",
-                    "timestamp": "2025-10-18T20:48:20.286204Z",
-                },
-                {
-                    "content": "Today is Saturday 18/10/2025.",
-                    "dynamic_ref": None,
-                    "part_kind": "system-prompt",
-                    "timestamp": "2025-10-18T20:48:20.286204Z",
-                },
-                {
-                    "content": "Answer in english.",
-                    "dynamic_ref": None,
-                    "part_kind": "system-prompt",
-                    "timestamp": "2025-10-18T20:48:20.286204Z",
-                },
                 {
                     "content": [
                         "What is in this image?",
@@ -219,6 +198,7 @@ def test_post_conversation_with_local_image_url(
                     "timestamp": "2025-10-18T20:48:20.286204Z",
                 },
             ],
+            "run_id": _run_id,
         },
         {
             "finish_reason": None,
@@ -241,6 +221,7 @@ def test_post_conversation_with_local_image_url(
                 "output_audio_tokens": 0,
                 "output_tokens": 9,
             },
+            "run_id": _run_id,
         },
     ]
 
@@ -282,11 +263,6 @@ def test_post_conversation_with_local_image_wrong_url(
         assert messages == [
             ModelRequest(
                 parts=[
-                    SystemPromptPart(
-                        content="You are a helpful test assistant :)", timestamp=timezone.now()
-                    ),
-                    SystemPromptPart(content=today_promt_date, timestamp=timezone.now()),
-                    SystemPromptPart(content="Answer in english.", timestamp=timezone.now()),
                     UserPromptPart(
                         content=[
                             "What is in this image?",
@@ -298,7 +274,10 @@ def test_post_conversation_with_local_image_wrong_url(
                         ],
                         timestamp=timezone.now(),
                     ),
-                ]
+                ],
+                instructions=f"You are a helpful test assistant :)\n\n{today_promt_date}"
+                "\n\nAnswer in english.",
+                run_id=messages[0].run_id,
             )
         ]
         yield "cannot read image."  # IRL a 400 error would be raised by the LLM
@@ -369,11 +348,6 @@ def test_post_conversation_with_remote_image_url(
         assert messages == [
             ModelRequest(
                 parts=[
-                    SystemPromptPart(
-                        content="You are a helpful test assistant :)", timestamp=timezone.now()
-                    ),
-                    SystemPromptPart(content=today_promt_date, timestamp=timezone.now()),
-                    SystemPromptPart(content="Answer in english.", timestamp=timezone.now()),
                     UserPromptPart(
                         content=[
                             "What is in this image?",
@@ -385,7 +359,10 @@ def test_post_conversation_with_remote_image_url(
                         ],
                         timestamp=timezone.now(),
                     ),
-                ]
+                ],
+                instructions="You are a helpful test assistant :)\n\n"
+                f"{today_promt_date}\n\nAnswer in english.",
+                run_id=messages[0].run_id,
             )
         ]
         yield "This is an image of a single pixel."
@@ -498,27 +475,10 @@ def test_post_conversation_with_local_image_url_in_history(
         ],
         pydantic_messages=[
             {
-                "instructions": None,
+                "instructions": f"You are a helpful test assistant :)\n\n{today_promt_date}"
+                "\n\nAnswer in english.",
                 "kind": "request",
                 "parts": [
-                    {
-                        "content": "You are a helpful test assistant :)",
-                        "dynamic_ref": None,
-                        "part_kind": "system-prompt",
-                        "timestamp": "2025-10-18T20:48:20.286204Z",
-                    },
-                    {
-                        "content": today_promt_date,
-                        "dynamic_ref": None,
-                        "part_kind": "system-prompt",
-                        "timestamp": "2025-10-18T20:48:20.286204Z",
-                    },
-                    {
-                        "content": "Answer in english.",
-                        "dynamic_ref": None,
-                        "part_kind": "system-prompt",
-                        "timestamp": "2025-10-18T20:48:20.286204Z",
-                    },
                     {
                         "content": [
                             "What is in this image?",
@@ -581,7 +541,7 @@ def test_post_conversation_with_local_image_url_in_history(
     )
 
     async def agent_model(messages: list[ModelMessage], _info: AgentInfo):
-        presigned_url = messages[0].parts[3].content[1].url
+        presigned_url = messages[0].parts[0].content[1].url
         assert presigned_url.startswith("http://localhost:9000/conversations-media-storage/")
         assert presigned_url.find("X-Amz-Signature=") != -1
         assert presigned_url.find("X-Amz-Date=") != -1
@@ -590,18 +550,6 @@ def test_post_conversation_with_local_image_url_in_history(
         assert messages == [
             ModelRequest(
                 parts=[
-                    SystemPromptPart(
-                        content="You are a helpful test assistant :)",
-                        timestamp=timezone.now(),
-                    ),
-                    SystemPromptPart(
-                        content=today_promt_date,
-                        timestamp=timezone.now(),
-                    ),
-                    SystemPromptPart(
-                        content="Answer in english.",
-                        timestamp=timezone.now(),
-                    ),
                     UserPromptPart(
                         content=[
                             "What is in this image?",
@@ -613,7 +561,9 @@ def test_post_conversation_with_local_image_url_in_history(
                         ],
                         timestamp=timezone.now(),
                     ),
-                ]
+                ],
+                instructions="You are a helpful test assistant :)\n\n"
+                f"{today_promt_date}\n\nAnswer in english.",
             ),
             ModelResponse(
                 parts=[TextPart(content="This is an image of a single pixel.")],
@@ -629,7 +579,10 @@ def test_post_conversation_with_local_image_url_in_history(
                         ],
                         timestamp=timezone.now(),
                     )
-                ]
+                ],
+                run_id=messages[2].run_id,
+                instructions="You are a helpful test assistant :)\n\n"
+                "Today is Saturday 18/10/2025.\n\nAnswer in english.",
             ),
         ]
         yield "This is an image of square, very small and nice."
@@ -725,29 +678,13 @@ def test_post_conversation_with_local_image_url_in_history(
         ],
     )
 
+    _run_id = chat_conversation.pydantic_messages[2]["run_id"]
     assert chat_conversation.pydantic_messages == [
         {
-            "instructions": None,
+            "instructions": f"You are a helpful test assistant :)\n\n{today_promt_date}"
+            "\n\nAnswer in english.",
             "kind": "request",
             "parts": [
-                {
-                    "content": "You are a helpful test assistant :)",
-                    "dynamic_ref": None,
-                    "part_kind": "system-prompt",
-                    "timestamp": "2025-10-18T20:48:20.286204Z",
-                },
-                {
-                    "content": today_promt_date,
-                    "dynamic_ref": None,
-                    "part_kind": "system-prompt",
-                    "timestamp": "2025-10-18T20:48:20.286204Z",
-                },
-                {
-                    "content": "Answer in english.",
-                    "dynamic_ref": None,
-                    "part_kind": "system-prompt",
-                    "timestamp": "2025-10-18T20:48:20.286204Z",
-                },
                 {
                     "content": [
                         "What is in this image?",
@@ -788,7 +725,8 @@ def test_post_conversation_with_local_image_url_in_history(
             },
         },
         {
-            "instructions": None,
+            "instructions": "You are a helpful test assistant :)\n\nToday is Saturday 18/10/2025."
+            "\n\nAnswer in english.",
             "kind": "request",
             "parts": [
                 {
@@ -797,6 +735,7 @@ def test_post_conversation_with_local_image_url_in_history(
                     "timestamp": "2025-10-18T20:48:20.286204Z",
                 }
             ],
+            "run_id": _run_id,
         },
         {
             "finish_reason": None,
@@ -823,5 +762,6 @@ def test_post_conversation_with_local_image_url_in_history(
                 "output_audio_tokens": 0,
                 "output_tokens": 11,
             },
+            "run_id": _run_id,
         },
     ]

src/backend/chat/tests/views/chat/conversations/test_stop_streaming.py

@@ -1,4 +1,4 @@
-"""Test the post_stop_steaming view."""
+"""Test the post_stop_streaming view."""
 
 from unittest.mock import patch
 

src/backend/chat/tools/data_analysis.py

@@ -0,0 +1,873 @@
+"""Data analysis tool for tabular files (CSV, Excel)."""
+
+import base64
+import functools
+import json
+import logging
+import uuid
+from io import BytesIO
+from typing import Any, Dict
+
+import matplotlib
+import numpy as np
+
+matplotlib.use("Agg")  # Use non-interactive backend
+import matplotlib.pyplot as plt
+import pandas as pd
+
+from django.conf import settings
+from django.core.files.storage import default_storage
+from django.db.models import Q
+from asgiref.sync import sync_to_async
+from pydantic_ai import Agent, RunContext
+from pydantic_ai.exceptions import ModelRetry
+from pydantic_ai.messages import ToolReturn
+
+from core.file_upload.enums import AttachmentStatus
+from core.file_upload.utils import generate_retrieve_policy
+
+from chat.agents.base import BaseAgent, prepare_custom_model
+from chat.models import ChatConversationAttachment
+from chat.tools.exceptions import ModelCannotRetry
+from chat.tools.utils import last_model_retry_soft_fail
+
+logger = logging.getLogger(__name__)
+
+# MIME types for tabular files
+TABULAR_MIME_TYPES = [
+    "text/csv",
+    "application/csv",
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    "application/vnd.ms-excel",
+    "application/excel",
+]
+
+
+@sync_to_async
+def read_tabular_file(attachment) -> bytes:
+    """Read tabular file content asynchronously."""
+    with default_storage.open(attachment.key, "rb") as f:
+        return f.read()
+
+
+def detect_csv_separator(file_data: bytes) -> str:
+    """
+    Detect the CSV separator by analyzing the first few lines.
+    
+    Returns the most likely separator: ',', ';', or '\t'
+    """
+    # Read first 10KB to analyze
+    sample = file_data[:10240].decode("utf-8", errors="ignore")
+    lines = sample.split("\n")[:10]  # First 10 lines
+    
+    if not lines:
+        return ","  # Default to comma
+    
+    # Count occurrences of each separator in the first few lines
+    comma_count = sum(line.count(",") for line in lines)
+    semicolon_count = sum(line.count(";") for line in lines)
+    tab_count = sum(line.count("\t") for line in lines)
+    
+    # Return the separator with the highest count
+    if tab_count > comma_count and tab_count > semicolon_count:
+        return "\t"
+    elif semicolon_count > comma_count:
+        return ";"
+    else:
+        return ","  # Default to comma
+
+
+def _convert_to_serializable(obj: Any) -> Any:
+    """
+    Convert pandas/numpy types to Python native types for JSON serialization.
+    
+    Handles:
+    - pandas DataFrame/Series
+    - numpy scalars (int64, float64, etc.)
+    - numpy arrays
+    - pandas Timestamp
+    - Other non-serializable types
+    
+    Args:
+        obj: The object to convert.
+        
+    Returns:
+        A JSON-serializable version of the object.
+    """
+    
+    # Handle pandas DataFrame
+    if isinstance(obj, pd.DataFrame):
+        # Limit number of rows to avoid huge responses
+        if len(obj) > 1000:
+            obj = obj.head(1000)
+            logger.warning("Result truncated to 1000 rows")
+        return obj.to_dict(orient="records")
+    
+    # Handle pandas Series
+    if isinstance(obj, pd.Series):
+        # Convert Series to dict, handling index
+        result_dict = obj.to_dict()
+        # Convert any numpy/pandas types in the values
+        return {str(k): _convert_to_serializable(v) for k, v in result_dict.items()}
+    
+    # Handle numpy scalars
+    if isinstance(obj, (np.integer, np.floating)):
+        return obj.item()  # Convert to Python native int/float
+    
+    # Handle numpy arrays
+    if isinstance(obj, np.ndarray):
+        return obj.tolist()
+    
+    # Handle pandas Timestamp
+    if isinstance(obj, pd.Timestamp):
+        return obj.isoformat()
+    
+    # Handle lists and tuples - recursively convert elements
+    if isinstance(obj, (list, tuple)):
+        return [_convert_to_serializable(item) for item in obj]
+    
+    # Handle dicts - recursively convert values
+    if isinstance(obj, dict):
+        return {str(k): _convert_to_serializable(v) for k, v in obj.items()}
+    
+    # Handle None, bool, int, float, str - these are already serializable
+    if obj is None or isinstance(obj, (bool, int, float, str)):
+        return obj
+    
+    # Fallback: try to convert to string
+    try:
+        return str(obj)
+    except Exception:
+        logger.warning("Could not serialize object of type %s, returning None", type(obj))
+        return None
+
+
+def _is_valid_excel_file(file_data: bytes, file_name: str) -> bool:
+    """
+    Check if the file data appears to be a valid Excel file.
+    
+    XLSX files are ZIP archives, so they should start with ZIP signature (PK\x03\x04).
+    XLS files have a different signature.
+    """
+    if not file_data:
+        return False
+    
+    file_lower = file_name.lower()
+    
+    # Check for XLSX (ZIP-based) signature
+    if file_lower.endswith((".xlsx", ".xlsm", ".xlsb")):
+        # XLSX files are ZIP archives, should start with PK\x03\x04
+        return file_data[:4] == b"PK\x03\x04"
+    
+    # Check for XLS (OLE2) signature
+    if file_lower.endswith(".xls"):
+        # XLS files are OLE2 compound documents, should start with specific signature
+        # Common signatures: 0xD0CF11E0 (OLE2) or 0x504B0304 (sometimes saved as ZIP)
+        return (
+            file_data[:4] == b"\xd0\xcf\x11\xe0"  # OLE2 signature
+            or file_data[:4] == b"PK\x03\x04"  # Sometimes XLS are actually ZIP
+        )
+    
+    return False
+
+
+@sync_to_async
+def load_dataframe(file_data: bytes, content_type: str, file_name: str) -> Dict[str, pd.DataFrame]:
+    """
+    Load tabular file into pandas DataFrames.
+    
+    Returns a dictionary mapping sheet/table names to DataFrames.
+    For CSV files, uses 'default' as the key.
+    For Excel files, uses sheet names as keys.
+    """
+    try:
+        # Handle CSV files - also accept text/plain if file extension is .csv
+        if content_type in ["text/csv", "application/csv"] or (
+            content_type == "text/plain" and file_name.lower().endswith(".csv")
+        ):
+            # Detect the separator
+            separator = detect_csv_separator(file_data)
+            logger.debug("Detected CSV separator: %r", separator)
+            
+            # Read CSV with detected separator
+            df = pd.read_csv(
+                BytesIO(file_data),
+                sep=separator,
+                on_bad_lines="skip",  # Skip problematic lines
+                engine="python",  # More flexible parser
+                encoding="utf-8",
+            )
+            
+            if df.empty:
+                raise ValueError("CSV file appears to be empty or could not be parsed")
+            
+            return {"default": df}
+        elif content_type in [
+            "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+            "application/vnd.ms-excel",
+            "application/excel",
+        ] or file_name.lower().endswith((".xlsx", ".xls", ".xlsm", ".xlsb")):
+            # Validate Excel file format before attempting to read
+            if not _is_valid_excel_file(file_data, file_name):
+                logger.warning(
+                    "File '%s' does not appear to be a valid Excel file. "
+                    "File size: %d bytes, First bytes: %r",
+                    file_name,
+                    len(file_data),
+                    file_data[:20] if len(file_data) >= 20 else file_data,
+                )
+                raise ValueError(
+                    f"File '{file_name}' does not appear to be a valid Excel file. "
+                    "It may be corrupted or in an unsupported format."
+                )
+            
+            file_lower = file_name.lower()
+            dataframes = {}
+            
+            # Try different engines based on file extension
+            if file_lower.endswith(".xls"):
+                # Old Excel format - try xlrd engine
+                try:
+                    logger.debug("Attempting to read .xls file with xlrd engine")
+                    excel_file = pd.ExcelFile(BytesIO(file_data), engine="xlrd")
+                    dataframes = {
+                        sheet_name: excel_file.parse(sheet_name)
+                        for sheet_name in excel_file.sheet_names
+                    }
+                except Exception as xlrd_error:
+                    logger.warning("Failed to read .xls with xlrd: %s", xlrd_error)
+                    # Fallback: try openpyxl (sometimes .xls files are actually .xlsx)
+                    try:
+                        logger.debug("Trying openpyxl as fallback for .xls file")
+                        excel_file = pd.ExcelFile(BytesIO(file_data), engine="openpyxl")
+                        dataframes = {
+                            sheet_name: excel_file.parse(sheet_name)
+                            for sheet_name in excel_file.sheet_names
+                        }
+                    except Exception as openpyxl_error:
+                        logger.error("Failed to read .xls with both engines: %s", openpyxl_error)
+                        raise ValueError(
+                            f"Failed to read Excel file '{file_name}': "
+                            f"xlrd error: {xlrd_error}, openpyxl error: {openpyxl_error}"
+                        ) from openpyxl_error
+            else:
+                # XLSX format - try openpyxl first
+                try:
+                    logger.debug("Attempting to read Excel file with openpyxl engine")
+                    excel_file = pd.ExcelFile(BytesIO(file_data), engine="openpyxl")
+                    dataframes = {
+                        sheet_name: excel_file.parse(sheet_name)
+                        for sheet_name in excel_file.sheet_names
+                    }
+                except Exception as openpyxl_error:
+                    logger.warning("Failed to read with openpyxl: %s", openpyxl_error)
+                    # Try calamine engine if available (faster and more robust)
+                    try:
+                        logger.debug("Trying calamine engine as fallback")
+                        excel_file = pd.ExcelFile(BytesIO(file_data), engine="calamine")
+                        dataframes = {
+                            sheet_name: excel_file.parse(sheet_name)
+                            for sheet_name in excel_file.sheet_names
+                        }
+                    except ImportError:
+                        logger.debug("calamine engine not available")
+                        raise ValueError(
+                            f"Failed to read Excel file '{file_name}' with openpyxl: {openpyxl_error}. "
+                            "The file may be corrupted or in an unsupported format."
+                        ) from openpyxl_error
+                    except Exception as calamine_error:
+                        logger.error("Failed to read with calamine: %s", calamine_error)
+                        raise ValueError(
+                            f"Failed to read Excel file '{file_name}': "
+                            f"openpyxl error: {openpyxl_error}, calamine error: {calamine_error}"
+                        ) from calamine_error
+            
+            if not dataframes:
+                raise ValueError(f"Excel file '{file_name}' contains no readable sheets")
+            
+            logger.info(
+                "Successfully loaded Excel file '%s' with %d sheet(s): %s",
+                file_name,
+                len(dataframes),
+                list(dataframes.keys()),
+            )
+            return dataframes
+        else:
+            raise ValueError(f"Unsupported content type: {content_type}")
+    except Exception as e:
+        logger.error("Error loading tabular file: %s", e, exc_info=True)
+        raise ModelCannotRetry(f"Failed to load file: {str(e)}") from e
+
+
+def generate_metadata(dataframes: Dict[str, pd.DataFrame], file_name: str) -> Dict[str, Any]:
+    """
+    Generate metadata about the tabular file.
+    
+    Returns:
+        Dictionary containing:
+        - sheets: List of sheet/table names
+        - schemas: Dictionary mapping sheet names to their schemas
+        - row_counts: Dictionary mapping sheet names to row counts
+        - column_info: Dictionary mapping sheet names to column information
+    """
+    metadata = {
+        "file_name": file_name,
+        "sheets": list(dataframes.keys()),
+        "schemas": {},
+        "row_counts": {},
+        "column_info": {},
+    }
+
+    for sheet_name, df in dataframes.items():
+        # Schema: column names and types
+        metadata["schemas"][sheet_name] = {
+            col: str(dtype) for col, dtype in df.dtypes.items()
+        }
+        
+        # Row count
+        metadata["row_counts"][sheet_name] = len(df)
+        
+        # Column info: name, type, sample values, null counts
+        metadata["column_info"][sheet_name] = {}
+        for col in df.columns:
+            col_info = {
+                "type": str(df[col].dtype),
+                "null_count": int(df[col].isna().sum()),
+                "unique_count": int(df[col].nunique()),
+            }
+            # Add sample values (non-null)
+            sample_values = df[col].dropna().head(5).tolist()
+            if sample_values:
+                col_info["sample_values"] = [str(v) for v in sample_values]
+            metadata["column_info"][sheet_name][col] = col_info
+
+    return metadata
+
+
+async def generate_query(
+    user_query: str, metadata: Dict[str, Any], query_agent: BaseAgent, ctx: RunContext
+) -> str:
+    """
+    Use an LLM agent to generate a pandas query from user query and file metadata.
+    """
+    metadata_str = json.dumps(metadata, indent=2)
+    
+    prompt = f"""You are a data analysis assistant. Given a user query and file metadata, generate a Python pandas query to answer the question.
+
+File metadata:
+{metadata_str}
+
+User query: {user_query}
+
+Generate a Python code snippet that:
+1. Uses pandas operations (filter, groupby, aggregate, etc.)
+2. Works with the dataframes loaded in memory (available as 'dataframes' dict)
+3. Assigns the final result to a variable named 'result'
+4. Handles the specific sheet/table if multiple sheets exist
+5. ALWAYS handles NaN/NA values in boolean conditions using .notna() or .fillna() before filtering
+6. If the user asks for a plot/graph/chart, create it using matplotlib and save to 'plot_image' variable as base64
+
+IMPORTANT RULES:
+- The code MUST assign the final result to a variable named 'result'
+- When filtering with conditions, ALWAYS check for NaN first: df[df['col'].notna() & (df['col'] > value)]
+- Use .dropna() if you need to remove rows with missing values
+- Use .fillna() if you need to replace missing values
+- If plotting: use plt (already imported), create the plot, convert to base64:
+  ```python
+  plt.figure(figsize=(10, 6))
+  # ... your plot code ...
+  buf = BytesIO()
+  plt.savefig(buf, format='png')
+  buf.seek(0)
+  plot_image = base64.b64encode(buf.getvalue()).decode('utf-8')
+  plt.close()
+  ```
+  NOTE: Do NOT use import statements - plt, base64, BytesIO are already available.
+
+Return ONLY the Python code, without markdown formatting or explanations. The code should be executable and use variables:
+- 'dataframes': dict mapping sheet names to DataFrames
+- Sheet names available: {', '.join(metadata['sheets'])}
+
+Example format (without plot):
+df = dataframes['default']
+df = df[df['column'].notna()]  # Remove NaN values first
+result = df[df['column'] > 100].groupby('category').sum()
+
+Example format (with plot):
+df = dataframes['default']
+plt.figure(figsize=(10, 6))
+plt.plot(df.index, df['close'])
+plt.xlabel('Index')
+plt.ylabel('Close')
+plt.title('Close vs Index')
+buf = BytesIO()
+plt.savefig(buf, format='png')
+buf.seek(0)
+plot_image = base64.b64encode(buf.getvalue()).decode('utf-8')
+plt.close()
+result = "Plot generated successfully. The plot image has been saved and is available in the tool response."
+
+IMPORTANT: 
+- Do NOT use import statements in the code. All necessary modules (pd, plt, np, base64, BytesIO) are already available. Do NOT use anything else than these modules.
+- When returning the result text, mention that a plot was generated and will be available in the response, but do NOT include the URL in the text - the system will handle displaying it.
+
+Generate the query code:"""
+
+    try:
+        response = await query_agent.run(prompt, usage=ctx.usage)
+        query_code = response.output.strip()
+        
+        # Extract code from markdown code blocks if present
+        if "```python" in query_code:
+            query_code = query_code.split("```python")[1].split("```")[0].strip()
+        elif "```" in query_code:
+            query_code = query_code.split("```")[1].split("```")[0].strip()
+        
+        return query_code
+    except Exception as e:
+        logger.error("Error generating query: %s", e, exc_info=True)
+        raise ModelRetry("Failed to generate query. Please try rephrasing your question.") from e
+
+
+@sync_to_async
+def execute_query(query_code: str, dataframes: Dict[str, pd.DataFrame]) -> Any:
+    """
+    Execute the generated pandas query safely.
+    
+    Note: Uses exec() in a restricted environment. The query code is generated
+    by an LLM based on file metadata, so it should be relatively safe, but
+    we restrict the available builtins and globals.
+    """
+    try:
+        # Pre-process dataframes to handle common issues
+        processed_dataframes = {}
+        for name, df in dataframes.items():
+            # Make a copy to avoid modifying original
+            df_processed = df.copy()
+            # Replace common NaN representations
+            df_processed = df_processed.replace(["", " ", "nan", "NaN", "None", "null"], pd.NA)
+            processed_dataframes[name] = df_processed
+        
+        # Create a safe execution environment
+        safe_globals = {
+            "pd": pd,
+            "plt": plt,
+            "np": np,
+            "base64": base64,
+            "BytesIO": BytesIO,
+            "dataframes": processed_dataframes,
+            "__builtins__": {
+                "len": len,
+                "str": str,
+                "int": int,
+                "float": float,
+                "bool": bool,
+                "list": list,
+                "dict": dict,
+                "set": set,
+                "tuple": tuple,
+                "range": range,
+                "sum": sum,
+                "max": max,
+                "min": min,
+                "abs": abs,
+                "round": round,
+            },
+        }
+        
+        # Clean up query code - remove any import statements that might cause issues
+        # Split by lines and filter out import statements
+        lines = query_code.split("\n")
+        cleaned_lines = [
+            line
+            for line in lines
+            if not line.strip().startswith("import ") and not line.strip().startswith("from ")
+        ]
+        query_code = "\n".join(cleaned_lines)
+        
+        # Execute the query in a restricted namespace
+        local_vars = {}
+        exec(query_code, safe_globals, local_vars)  # noqa: S102
+        
+        # Get the result - check if 'result' variable exists, otherwise try 'df'
+        if "result" in local_vars:
+            result = local_vars["result"]
+        elif "df" in local_vars:
+            result = local_vars["df"]
+        else:
+            # If no explicit result variable, get the last expression
+            # This is a fallback - ideally the LLM should assign to 'result'
+            raise ValueError("Query must assign result to 'result' variable")
+        
+        # Check if a plot was generated
+        plot_image = None
+        if "plot_image" in local_vars:
+            plot_image = local_vars["plot_image"]
+            logger.info("Plot image generated")
+        
+        # Convert result to a serializable format
+        result = _convert_to_serializable(result)
+        
+        return {"result": result, "plot_image": plot_image}
+    except Exception as e:
+        logger.error("Error executing query: %s", e, exc_info=True)
+        # Provide more helpful error message
+        error_msg = str(e)
+        if "NaN" in error_msg or "NA" in error_msg:
+            error_msg = (
+                f"{error_msg}. "
+                "The query may need to handle missing values (NaN/NA) using .notna() or .dropna() before filtering."
+            )
+        raise ModelCannotRetry(f"Failed to execute query: {error_msg}") from e
+
+
+@last_model_retry_soft_fail
+async def data_analysis(ctx: RunContext, query: str) -> ToolReturn:
+    """
+    Analyze tabular data files (CSV, Excel) based on user query.
+    Can also generate plots/graphs/charts.
+    
+    This tool:
+    1. Loads the tabular file(s) from attachments
+    2. Generates metadata about the file structure
+    3. Uses an LLM to generate a pandas query based on user query
+    4. Executes the query and returns results
+    
+    Args:
+        ctx (RunContext): The run context containing the conversation.
+        query (str): The user's data analysis question.
+    
+    Returns:
+        ToolReturn: Contains the analysis results and metadata.
+    """
+    try:
+        # Find tabular files in attachments
+        # First, get all attachments for debugging
+        all_attachments = await sync_to_async(list)(
+            ctx.deps.conversation.attachments.all()
+        )
+        logger.info(
+            "All attachments in conversation: %s",
+            [
+                {
+                    "file_name": a.file_name,
+                    "content_type": a.content_type,
+                    "upload_state": a.upload_state,
+                    "conversion_from": a.conversion_from,
+                }
+                for a in all_attachments
+            ],
+        )
+
+        # Find tabular files - exclude converted files (they have conversion_from set)
+        # First try by content_type
+        tabular_attachments_by_type = await sync_to_async(list)(
+            ctx.deps.conversation.attachments.filter(
+                content_type__in=TABULAR_MIME_TYPES,
+                upload_state=AttachmentStatus.READY,
+            )
+            .filter(
+                Q(conversion_from__isnull=True) | Q(conversion_from="")
+            )
+        )
+        
+        # If no files found by content_type, try by file extension as fallback
+        # (some systems detect CSV as text/plain instead of text/csv)
+        if not tabular_attachments_by_type:
+            csv_extensions = [".csv", ".xlsx", ".xls"]
+            all_ready_attachments = await sync_to_async(list)(
+                ctx.deps.conversation.attachments.filter(
+                    upload_state=AttachmentStatus.READY,
+                )
+                .filter(
+                    Q(conversion_from__isnull=True) | Q(conversion_from="")
+                )
+            )
+            tabular_attachments = [
+                att
+                for att in all_ready_attachments
+                if any(att.file_name.lower().endswith(ext) for ext in csv_extensions)
+                # Exclude Markdown files (converted files have .md extension or content_type text/markdown)
+                and not att.file_name.lower().endswith(".md")
+                and att.content_type != "text/markdown"
+            ]
+            if tabular_attachments:
+                logger.info(
+                    "Found %d tabular file(s) by extension fallback (content_type was not recognized): %s",
+                    len(tabular_attachments),
+                    [f"{a.file_name} ({a.content_type})" for a in tabular_attachments],
+                )
+        else:
+            tabular_attachments = tabular_attachments_by_type
+
+        # If still no files found, check if there are converted files that might have originals
+        # This handles the case where an Excel file was converted to Markdown for RAG
+        if not tabular_attachments:
+            # Look for converted files with tabular extensions
+            csv_extensions = [".csv", ".xlsx", ".xls"]
+            converted_attachments = await sync_to_async(list)(
+                ctx.deps.conversation.attachments.filter(
+                    upload_state=AttachmentStatus.READY,
+                )
+                .exclude(
+                    Q(conversion_from__isnull=True) | Q(conversion_from="")
+                )
+            )
+            
+            # For each converted file, try to find the original
+            for converted_att in converted_attachments:
+                if any(converted_att.file_name.lower().endswith(ext) for ext in csv_extensions):
+                    # Try to find the original file using conversion_from key
+                    original_key = converted_att.conversion_from
+                    if original_key:
+                        original_attachment = await sync_to_async(
+                            ctx.deps.conversation.attachments.filter(
+                                key=original_key,
+                                upload_state=AttachmentStatus.READY,
+                            ).first
+                        )()
+                        if original_attachment:
+                            logger.info(
+                                "Found original file '%s' for converted file '%s'",
+                                original_attachment.file_name,
+                                converted_att.file_name,
+                            )
+                            tabular_attachments.append(original_attachment)
+                            break
+
+        logger.info(
+            "Found %d tabular attachment(s): %s",
+            len(tabular_attachments),
+            [f"{a.file_name} ({a.content_type})" for a in tabular_attachments],
+        )
+
+        if not tabular_attachments:
+            raise ModelCannotRetry(
+                "No tabular files (CSV or Excel) found in the conversation. "
+                "Please upload a CSV or Excel file first. "
+                "Note: If you uploaded an Excel file that was converted to Markdown for RAG, "
+                "the original file must still be available."
+            )
+
+        # Use the first tabular file
+        attachment = tabular_attachments[0]
+        logger.info("Analyzing file: %s (type: %s)", attachment.file_name, attachment.content_type)
+
+        # Load file data
+        file_data = await read_tabular_file(attachment)
+        
+        # Validate that this is actually a valid Excel/CSV file (not a converted Markdown file)
+        # Check if it's an Excel file that should have ZIP signature
+        if attachment.file_name.lower().endswith((".xlsx", ".xls", ".xlsm", ".xlsb")):
+            if not _is_valid_excel_file(file_data, attachment.file_name):
+                logger.warning(
+                    "File '%s' does not appear to be a valid Excel file. "
+                    "It may be a converted Markdown file. Searching for original...",
+                    attachment.file_name,
+                )
+                # Try to find the original file
+                # Look for an attachment with the same name but without conversion_from
+                original_attachment = await sync_to_async(
+                    ctx.deps.conversation.attachments.filter(
+                        file_name=attachment.file_name,
+                        upload_state=AttachmentStatus.READY,
+                    )
+                    .filter(
+                        Q(conversion_from__isnull=True) | Q(conversion_from="")
+                    )
+                    .exclude(pk=attachment.pk)
+                    .first
+                )()
+                
+                if original_attachment:
+                    logger.info(
+                        "Found original file '%s' (key: %s), using it instead",
+                        original_attachment.file_name,
+                        original_attachment.key,
+                    )
+                    attachment = original_attachment
+                    file_data = await read_tabular_file(attachment)
+                elif hasattr(attachment, 'conversion_from') and attachment.conversion_from:
+                    # Try to find by key if this file has a conversion_from
+                    original_attachment = await sync_to_async(
+                        ctx.deps.conversation.attachments.filter(
+                            key=attachment.conversion_from,
+                            upload_state=AttachmentStatus.READY,
+                        ).first
+                    )()
+                    if original_attachment:
+                        logger.info(
+                            "Found original file via conversion_from: '%s'",
+                            original_attachment.file_name,
+                        )
+                        attachment = original_attachment
+                        file_data = await read_tabular_file(attachment)
+                    else:
+                        raise ModelCannotRetry(
+                            f"File '{attachment.file_name}' appears to be a converted Markdown file, "
+                            "not the original Excel file. The original file is not available. "
+                            "Please re-upload the original Excel file."
+                        )
+                else:
+                    raise ModelCannotRetry(
+                        f"File '{attachment.file_name}' does not appear to be a valid Excel file. "
+                        "It may be corrupted or in an unsupported format."
+                    )
+
+        # Load into pandas DataFrames
+        dataframes = await load_dataframe(file_data, attachment.content_type, attachment.file_name)
+
+        # Generate metadata
+        metadata = generate_metadata(dataframes, attachment.file_name)
+        logger.debug("File metadata: %s", json.dumps(metadata, indent=2))
+
+        # Generate query using LLM
+        # NOTE:
+        # We intentionally create a "bare" Agent instance here instead of using BaseAgent
+        # with tools enabled. Using BaseAgent would attach all configured tools (including
+        # this data_analysis tool itself), which can cause the model to try to call tools
+        # while we're already inside a tool execution, leading to nested tool calls and
+        # failures like "Failed to generate query. Please try rephrasing your question.".
+        #
+        # Here we reuse the same model configuration as BaseAgent but WITHOUT any tools,
+        # so this internal call is purely text-to-text.
+        llm_config = settings.LLM_CONFIGURATIONS[settings.LLM_DEFAULT_MODEL_HRID]
+        if llm_config.is_custom:
+            model_instance = prepare_custom_model(llm_config)
+        else:
+            # Rely on pydantic-ai's built-in model registry / name inference
+            model_instance = llm_config.model_name
+
+        # Use the same keyword as when using BaseAgent, which forwards to Agent.
+        # On the current pydantic_ai version, the correct kwarg is `output_type`,
+        # not `result_type` (passing `result_type` raises a UserError).
+        query_agent = Agent(model=model_instance, output_type=str)
+        query_code = await generate_query(query, metadata, query_agent, ctx)
+        logger.debug("Generated query: %s", query_code)
+
+        # Execute query
+        try:
+            execution_result = await execute_query(query_code, dataframes)
+            result = execution_result.get("result")
+            plot_image_base64 = execution_result.get("plot_image")
+        except Exception as e:
+            logger.error("Query execution failed: %s", e, exc_info=True)
+            raise ModelRetry(
+                f"Failed to execute the generated query: {str(e)}. "
+                "Please try rephrasing your question."
+            ) from e
+
+        # Format result for return
+        return_value = {
+            "query": query,
+            "query_code": query_code,
+            "result": result,
+            "metadata": metadata,
+        }
+        
+        # Save plot image to storage if generated
+        plot_url = None
+        plot_attachment = None
+        if plot_image_base64:
+            try:
+                # Decode base64 image
+                plot_image_data = base64.b64decode(plot_image_base64)
+                
+                # Generate a unique filename for the plot
+                plot_filename = f"plot_{uuid.uuid4().hex[:8]}.png"
+                plot_key = f"{ctx.deps.conversation.pk}/plots/{plot_filename}"
+                
+                # Save to storage
+                await sync_to_async(default_storage.save)(
+                    plot_key, BytesIO(plot_image_data)
+                )
+                
+                # Create a permanent attachment record in the database
+                plot_attachment = await sync_to_async(ChatConversationAttachment.objects.create)(
+                    conversation=ctx.deps.conversation,
+                    uploaded_by=ctx.deps.user,
+                    key=plot_key,
+                    file_name=plot_filename,
+                    content_type="image/png",
+                    upload_state=AttachmentStatus.READY,
+                    size=len(plot_image_data),
+                )
+                
+                # Generate presigned URL for immediate access (valid for 1 hour)
+                plot_url = await sync_to_async(generate_retrieve_policy)(plot_key)
+                logger.info(
+                    "Plot image saved to storage and database: %s (presigned URL: %s)", 
+                    plot_key, 
+                    plot_url[:50] + "..."
+                )
+            except Exception as e:
+                logger.error("Failed to save plot image: %s", e, exc_info=True)
+                # Continue without plot URL if save fails
+        
+        if plot_url:
+            # Include both local and presigned URLs
+            return_value["plot_url"] = plot_url  # Presigned URL for direct access
+            return_value["plot_local_url"] = f"/media-key/{plot_key}"  # Local URL for reference
+            # Include attachment ID for reference
+            if plot_attachment:
+                return_value["plot_attachment_id"] = str(plot_attachment.pk)
+        
+        return ToolReturn(
+            return_value=return_value,
+            metadata={"file_name": attachment.file_name, "content_type": attachment.content_type},
+        )
+
+    except (ModelCannotRetry, ModelRetry):
+        # Re-raise these as-is
+        raise
+    except Exception as exc:
+        # Unexpected error - stop and inform user
+        logger.exception("Unexpected error in data_analysis: %s", exc)
+        raise ModelCannotRetry(
+            f"An unexpected error occurred during data analysis: {type(exc).__name__}. "
+            "You must explain this to the user and not try to answer based on your knowledge."
+        ) from exc
+
+
+def add_data_analysis_tool(agent: Agent) -> None:
+    """Add the data analysis tool to an existing agent."""
+
+    @agent.tool(retries=2)
+    @functools.wraps(data_analysis)
+    async def data_analysis_tool(ctx: RunContext, query: str) -> ToolReturn:
+        """
+        Analyze tabular data files (CSV, Excel) based on user query.
+        
+        This tool loads tabular files, generates metadata about their structure,
+        uses an LLM to generate a pandas query based on the user's question,
+        executes the query, and returns the results.
+        
+        Use this tool when the user asks questions about data in CSV or Excel files,
+        such as:
+        - "What is the average sales by region?"
+        - "Show me the top 10 products by revenue"
+        - "How many records are in this file?"
+        - "Filter data where column X is greater than Y"
+        
+        Args:
+            ctx (RunContext): The run context containing the conversation.
+            query (str): The user's data analysis question.
+        """
+        # Import here to avoid circular import
+        from chat.tools.data_analysis import data_analysis as _data_analysis
+        
+        return await _data_analysis(ctx, query)
+
+    @agent.instructions
+    def data_analysis_instructions() -> str:
+        """Dynamic system prompt function to add data analysis instructions."""
+        return (
+            "When the user asks questions about data in CSV or Excel files, "
+            "use the data_analysis tool to analyze the data and answer their question. "
+            "The tool will handle loading the file, generating queries, and executing them. "
+            "When a plot is generated, the tool returns a 'plot_url' in the result. "
+            "Use this presigned URL directly in markdown image syntax: ![Description](plot_url). "
+            "Do NOT use local URLs like /media-key/... - always use the presigned URL from plot_url. "
+            "Present the results clearly to the user."
+        )
+

src/backend/chat/tools/document_generic_search_rag.py

@@ -0,0 +1,137 @@
+"""
+Helpers to add RAG document search tools to an agent based on settings.
+
+The purpose is to provide a generic way to add multiple RAG document search tools
+to an agent based on configuration in settings. Each tool can target specific
+document collections and have its own description.
+
+Our use case implies that different users might have access to different document collections,
+so the tools added to the agent are also user-specific.
+"""
+
+import logging
+
+from django.conf import settings
+from django.contrib.auth import get_user_model
+from django.utils.module_loading import import_string
+
+from httpx import HTTPStatusError
+from pydantic_ai import Agent, ModelRetry, RunContext, RunUsage
+from pydantic_ai.messages import ToolReturn
+
+from core.feature_flags.helpers import is_feature_enabled
+
+from chat.tools.utils import last_model_retry_soft_fail
+
+logger = logging.getLogger(__name__)
+
+User = get_user_model()
+
+
+def get_specific_rag_search_tool_config(user: User) -> dict:
+    """
+    Get the specific RAG search tool configuration from settings.
+
+    Settings example:
+    SPECIFIC_RAG_DOCUMENT_SEARCH_TOOLS = {
+        "french_public_services": {
+            "collection_ids": [784, 785],
+            "feature_flag_value": "disabled",
+            "tool_description": (
+                "Use this tool when the user asks for information about French public services, "
+                "the French labor market, employment laws, social benefits, or "
+                "assistance with administrative procedures."
+            ),
+        },
+    }
+    """
+    return {
+        tool_name: tool_config
+        for tool_name, tool_config in settings.SPECIFIC_RAG_DOCUMENT_SEARCH_TOOLS.items()
+        if is_feature_enabled(user, tool_name)
+    }
+
+
+def _create_document_search_rag(agent, name, description, backend, ids):
+    """Factory function to create a document search RAG tool."""
+
+    @agent.tool(
+        name=name,
+        retries=1,
+        require_parameter_descriptions=True,
+        description=description,
+    )
+    @last_model_retry_soft_fail
+    async def document_search_rag(ctx: RunContext, query: str) -> ToolReturn:
+        """
+        Args:
+            ctx (RunContext): The run context containing the conversation.
+            query (str): The query to search information about.
+        """
+        document_store = backend(read_only_collection_id=ids)
+
+        try:
+            rag_results = await document_store.asearch(query)
+        except HTTPStatusError as exc:
+            logger.error(
+                "RAG document search failed for tool %s with error: %s", name, exc, exc_info=True
+            )
+            raise ModelRetry(f"Document search service is currently unavailable: {exc}") from exc
+
+        ctx.usage += RunUsage(
+            input_tokens=rag_results.usage.prompt_tokens,
+            output_tokens=rag_results.usage.completion_tokens,
+        )
+
+        return ToolReturn(
+            return_value={
+                str(idx): {
+                    "url": result.url,
+                    "snippets": result.content,
+                }
+                for idx, result in enumerate(rag_results.data)
+            },
+            metadata={"sources": {result.url for result in rag_results.data}},
+        )
+
+    return document_search_rag
+
+
+def add_document_rag_search_tool_from_setting(agent: Agent, user: User) -> None:
+    """
+    This function takes a configuration setting and generates specific search RAG tools and add
+    it to the agent.
+
+    Args:
+        agent (Agent): The agent to which the tool will be added.
+        user (User): The user for whom the tool is being added.
+    """
+
+    for tool_name, tool_config in get_specific_rag_search_tool_config(user).items():
+        document_store_backend_name = tool_config.get(
+            "rag_backend_name", settings.RAG_DOCUMENT_SEARCH_BACKEND
+        )
+        try:
+            document_store_backend = import_string(document_store_backend_name)
+        except ImportError as exc:
+            logger.warning(
+                "Could not import RAG backend %s: %s",
+                document_store_backend_name,
+                exc,
+                exc_info=True,
+            )
+            continue  # Skip if the backend is not available
+
+        collection_ids = tool_config.get("collection_ids", [])
+        if not collection_ids:
+            logger.warning("No collection IDs provided for tool %s, skipping.", tool_name)
+            continue  # Skip if no collection IDs are provided
+
+        tool_description = tool_config.get("tool_description")
+        if not tool_description:
+            logger.warning("No tool description provided for tool %s, skipping.", tool_name)
+            continue  # Skip if no tool description is provided
+
+        _create_document_search_rag(
+            agent, tool_name, tool_description, document_store_backend, collection_ids
+        )

src/backend/chat/tools/document_search_rag.py

@@ -39,7 +39,7 @@ def add_document_rag_search_tool(agent: Agent) -> None:
             metadata={"sources": {result.url for result in rag_results.data}},
         )
 
-    @agent.system_prompt
+    @agent.instructions
     def document_rag_instructions() -> str:
         """Dynamic system prompt function to add RAG instructions if any."""
         return (

src/backend/chat/tools/exceptions.py

@@ -3,17 +3,6 @@
 from pydantic_ai import ModelRetry
 
 
-class ModelRetryLast(ModelRetry):
-    """
-    Same as ModelRetry but also holds the last retry message to return when all attempts failed.
-    """
-
-    def __init__(self, message: str, last_retry_message: str):
-        """Initialize ModelRetryLast with message and last retry message."""
-        self.last_retry_message = last_retry_message
-        super().__init__(message)
-
-
 class ModelCannotRetry(ModelRetry):
     """
     Exception to raise when a tool function cannot be retried.

src/backend/chat/views.py

@@ -221,7 +221,7 @@ class ChatViewSet(  # pylint: disable=too-many-ancestors, abstract-method
         url_path="stop-streaming",
         url_name="stop-streaming",
     )
-    def post_stop_steaming(self, request, pk):  # pylint: disable=unused-argument
+    def post_stop_streaming(self, request, pk):  # pylint: disable=unused-argument
         """Handle POST requests to stop streaming the chat conversation.
 
         This action will put a poison pill in the redis cache to stop any ongoing streaming.

src/backend/conftest.py

@@ -1,5 +1,6 @@
 """Global fixtures for the backend tests."""
 
+import posthog
 import pytest
 from rest_framework.test import APIClient
 from urllib3.connectionpool import HTTPConnectionPool
@@ -41,3 +42,17 @@ def feature_flags_fixture(settings):
     """
     settings.FEATURE_FLAGS = settings.FEATURE_FLAGS.model_copy(deep=True)
     yield settings.FEATURE_FLAGS
+
+
+@pytest.fixture(name="posthog", scope="function")
+def posthog_fixture(settings):
+    """Mock PostHog in tests to avoid real network calls."""
+    settings.POSTHOG_KEY = {"id": "132456", "host": "https://eu.i.posthog-test.com"}
+
+    posthog.api_key = settings.POSTHOG_KEY["id"]
+    posthog.host = settings.POSTHOG_KEY["host"]
+
+    yield posthog
+
+    posthog.api_key = None
+    posthog.host = None

src/backend/conversations/configuration/llm/default.e2e.json

@@ -0,0 +1,43 @@
+{
+  "models": [
+    {
+      "hrid": "default-model",
+      "model_name": "mistral-mock",
+      "human_readable_name": "Default Model",
+      "provider_name": "default-provider",
+      "profile": null,
+      "settings": {},
+      "is_active": true,
+      "icon": [
+        "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAMAAABF0y+mAAAAn1BMVEUALosAKoovTZjw8vb////+9/jlPUniAAz",
+        "iABUAGIWbpsTwq7HhAAAAI4dle7DrdX4AJohRaaboXWj7+/zn6On5//9NZaT29vfoWmVHYKDoUl/k5OUAIYddc6vpbHYCM47Y3+v53+LiFCUA",
+        "HIWnsckYPJHi6PL77O7jJjW3wdf1w8jre4QgQ5TZ2txwg7Pr3+I8WZ6OnsTuoamClL7tlZ5xz5y8AAAAzUlEQVR4AZ3RRQKDQBBEUSTu7h5c4",
+        "vc/W6Yp3KG2Dz4ynDdeEBvOmq12xx2E1u0B+4NOEocj4DgNJ1PgLAvni8WyBq5Yc71ubFJx23C2q4P7dRYejg1xzvCUgvz5guz11k7gXYKF/1",
+        "8oyiYuvHAYeVkhXCzolVStHcGDjiQzNmMQxsMI5rEJRdQSPZvbpE2E8aY6gC6Z+2Hg4dFA0Yb4YedNL/v4Fk8WJuwiGhrChJNXI210rnib9Fs",
+        "JlXRUC/HwTscPIXf/iklq/tjb/gHAdxkCUjAg2QAAAABJRU5ErkJggg=="
+      ],
+      "system_prompt": "You are a helpful AI assistant.",
+      "tools": []
+    },
+    {
+      "hrid": "default-summarization-model",
+      "model_name": "mistral-mock",
+      "human_readable_name": "Default Summarization Model",
+      "provider_name": "default-provider",
+      "profile": null,
+      "settings": {},
+      "is_active": true,
+      "icon": null,
+      "system_prompt": "You are a helpful AI assistant specialized in summarization.",
+      "tools": []
+    }
+  ],
+  "providers": [
+    {
+      "hrid": "default-provider",
+      "base_url": "http://host.docker.internal:8900",
+      "api_key": "openmockllm-api-key",
+      "kind": "mistral"
+    }
+  ]
+}

src/backend/conversations/settings.py

@@ -717,6 +717,11 @@ class Base(BraveSettings, Configuration):
         environ_name="RAG_DOCUMENT_SEARCH_BACKEND",
         environ_prefix=None,
     )
+    SPECIFIC_RAG_DOCUMENT_SEARCH_TOOLS = values.DictValue(
+        default={},
+        environ_name="SPECIFIC_RAG_DOCUMENT_SEARCH_TOOLS",
+        environ_prefix=None,
+    )
 
     # Web search
     RAG_WEB_SEARCH_PROMPT_UPDATE = values.Value(

src/backend/core/api/__init__.py

@@ -1,12 +1,9 @@
 """Conversations core API endpoints"""
 
-from django.conf import settings
 from django.core.exceptions import ValidationError
 
 from rest_framework import exceptions as drf_exceptions
 from rest_framework import views as drf_views
-from rest_framework.decorators import api_view
-from rest_framework.response import Response
 
 
 def exception_handler(exc, context):
@@ -28,14 +25,3 @@ def exception_handler(exc, context):
         exc = drf_exceptions.ValidationError(detail=detail)
 
     return drf_views.exception_handler(exc, context)
-
-
-# pylint: disable=unused-argument
-@api_view(["GET"])
-def get_frontend_configuration(request):
-    """Returns the frontend configuration dict as configured in settings."""
-    frontend_configuration = {
-        "LANGUAGE_CODE": settings.LANGUAGE_CODE,
-    }
-    frontend_configuration.update(settings.FRONTEND_CONFIGURATION)
-    return Response(frontend_configuration)

src/backend/core/api/serializers.py

@@ -20,23 +20,3 @@ class UserSerializer(serializers.ModelSerializer):
             "sub",
         ]
         read_only_fields = ["id", "email", "full_name", "short_name", "sub"]
-
-
-class UserLightSerializer(UserSerializer):
-    """Serialize users with limited fields."""
-
-    id = serializers.SerializerMethodField(read_only=True)
-    email = serializers.SerializerMethodField(read_only=True)
-
-    def get_id(self, _user):
-        """Return always None. Here to have the same fields than in UserSerializer."""
-        return None
-
-    def get_email(self, _user):
-        """Return always None. Here to have the same fields than in UserSerializer."""
-        return None
-
-    class Meta:
-        model = models.User
-        fields = ["id", "email", "full_name", "short_name"]
-        read_only_fields = ["id", "email", "full_name", "short_name"]

src/backend/core/authentication/__init__.py

@@ -1,52 +0,0 @@
-"""Custom authentication classes for the Conversations core app"""
-
-from django.conf import settings
-
-from rest_framework.authentication import BaseAuthentication
-from rest_framework.exceptions import AuthenticationFailed
-
-
-class ServerToServerAuthentication(BaseAuthentication):
-    """
-    Custom authentication class for server-to-server requests.
-    Validates the presence and correctness of the Authorization header.
-    """
-
-    AUTH_HEADER = "Authorization"
-    TOKEN_TYPE = "Bearer"  # noqa S105
-
-    def authenticate(self, request):
-        """
-        Authenticate the server-to-server request by validating the Authorization header.
-
-        This method checks if the Authorization header is present in the request, ensures it
-        contains a valid token with the correct format, and verifies the token against the
-        list of allowed server-to-server tokens. If the header is missing, improperly formatted,
-        or contains an invalid token, an AuthenticationFailed exception is raised.
-
-        Returns:
-            None: If authentication is successful
-                  (no user is authenticated for server-to-server requests).
-
-        Raises:
-            AuthenticationFailed: If the Authorization header is missing, malformed,
-            or contains an invalid token.
-        """
-        auth_header = request.headers.get(self.AUTH_HEADER)
-        if not auth_header:
-            raise AuthenticationFailed("Authorization header is missing.")
-
-        # Validate token format and existence
-        auth_parts = auth_header.split(" ")
-        if len(auth_parts) != 2 or auth_parts[0] != self.TOKEN_TYPE:
-            raise AuthenticationFailed("Invalid authorization header.")
-
-        token = auth_parts[1]
-        if token not in settings.SERVER_TO_SERVER_API_TOKENS:
-            raise AuthenticationFailed("Invalid server-to-server token.")
-
-        # Authentication is successful, but no user is authenticated
-
-    def authenticate_header(self, request):
-        """Return the WWW-Authenticate header value."""
-        return f"{self.TOKEN_TYPE} realm='Create document server to server'"

src/backend/core/feature_flags/flags.py

@@ -2,6 +2,7 @@
 
 from enum import StrEnum
 
+from django.conf import settings
 from django.utils.text import slugify
 
 from pydantic import BaseModel, ConfigDict
@@ -43,3 +44,9 @@ class FeatureFlags(BaseModel):
     # features
     web_search: FeatureToggle = FeatureToggle.DISABLED
     document_upload: FeatureToggle = FeatureToggle.DISABLED
+
+    def __getattr__(self, name: str):
+        """Dynamically get specific RAG document search tool feature flags from settings."""
+        if config := settings.SPECIFIC_RAG_DOCUMENT_SEARCH_TOOLS.get(name):
+            return FeatureToggle[config.get("feature_flag_value", "DISABLED").upper()]
+        return super().__getattr__(name)

src/backend/core/fields.py

@@ -1,25 +0,0 @@
-"""A JSONField for DRF to handle serialization/deserialization."""
-
-import json
-
-from rest_framework import serializers
-
-
-class JSONField(serializers.Field):
-    """
-    A custom field for handling JSON data.
-    """
-
-    def to_representation(self, value):
-        """
-        Convert the JSON string to a Python dictionary for serialization.
-        """
-        return value
-
-    def to_internal_value(self, data):
-        """
-        Convert the Python dictionary to a JSON string for deserialization.
-        """
-        if data is None:
-            return None
-        return json.dumps(data)

src/backend/core/filters.py

@@ -2,31 +2,9 @@
 
 import unicodedata
 
-import django_filters
-
 
 def remove_accents(value):
     """Remove accents from a string (vélo -> velo)."""
     return "".join(
         c for c in unicodedata.normalize("NFD", value) if unicodedata.category(c) != "Mn"
     )
-
-
-class AccentInsensitiveCharFilter(django_filters.CharFilter):
-    """
-    A custom CharFilter that filters on the accent-insensitive value searched.
-    """
-
-    def filter(self, qs, value):
-        """
-        Apply the filter to the queryset using the unaccented version of the field.
-
-        Args:
-            qs: The queryset to filter.
-            value: The value to search for in the unaccented field.
-        Returns:
-            A filtered queryset.
-        """
-        if value:
-            value = remove_accents(value)
-        return super().filter(qs, value)

src/backend/core/migrations/0003_alter_user_short_name.py

@@ -0,0 +1,17 @@
+# Generated by Django 5.2.8 on 2025-12-01 08:40
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("core", "0002_user_allow_conversation_analytics"),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name="user",
+            name="short_name",
+            field=models.CharField(blank=True, max_length=50, null=True, verbose_name="short name"),
+        ),
+    ]

src/backend/core/models.py

@@ -114,7 +114,7 @@ class User(AbstractBaseUser, BaseModel, auth_models.PermissionsMixin):
     )
 
     full_name = models.CharField(_("full name"), max_length=100, null=True, blank=True)
-    short_name = models.CharField(_("short name"), max_length=20, null=True, blank=True)
+    short_name = models.CharField(_("short name"), max_length=50, null=True, blank=True)
 
     email = models.EmailField(_("identity email address"), blank=True, null=True)
 

src/backend/core/templates/core/generate_document.html

@@ -1,14 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-    <title>Generate Document</title>
-</head>
-<body>
-    <h2>Generate Document</h2>
-    <form method="post" enctype="multipart/form-data">
-        {% csrf_token %}
-        {{ form.as_p }}
-        <button type="submit">Generate PDF</button>
-    </form>
-</body>
-</html>

src/backend/core/templatetags/extra_tags.py

@@ -1,58 +0,0 @@
-"""Custom template tags for the core application of People."""
-
-import base64
-
-from django import template
-from django.contrib.staticfiles import finders
-
-from PIL import ImageFile as PillowImageFile
-
-register = template.Library()
-
-
-def image_to_base64(file_or_path, close=False):
-    """
-    Return the src string of the base64 encoding of an image represented by its path
-    or file opened or not.
-
-    Inspired by Django's "get_image_dimensions"
-    """
-    pil_parser = PillowImageFile.Parser()
-    if hasattr(file_or_path, "read"):
-        file = file_or_path
-        if file.closed and hasattr(file, "open"):
-            file_or_path.open()
-        file_pos = file.tell()
-        file.seek(0)
-    else:
-        try:
-            # pylint: disable=consider-using-with
-            file = open(file_or_path, "rb")
-        except OSError:
-            return ""
-        close = True
-
-    try:
-        image_data = file.read()
-        if not image_data:
-            return ""
-        pil_parser.feed(image_data)
-        if pil_parser.image:
-            mime_type = pil_parser.image.get_format_mimetype()
-            encoded_string = base64.b64encode(image_data)
-            return f"data:{mime_type:s};base64, {encoded_string.decode('utf-8'):s}"
-        return ""
-    finally:
-        if close:
-            file.close()
-        else:
-            file.seek(file_pos)
-
-
-@register.simple_tag
-def base64_static(path):
-    """Return a static file into a base64."""
-    full_path = finders.find(path)
-    if full_path:
-        return image_to_base64(full_path, True)
-    return ""

src/backend/locale/de_DE/LC_MESSAGES/django.po

@@ -3,7 +3,7 @@ msgstr ""
 "Project-Id-Version: la-suite-conversations\n"
 "Report-Msgid-Bugs-To: \n"
 "POT-Creation-Date: 2025-10-20 21:48+0000\n"
-"PO-Revision-Date: 2025-11-10 12:20\n"
+"PO-Revision-Date: 2025-12-15 13:49\n"
 "Last-Translator: \n"
 "Language-Team: German\n"
 "Language: de_DE\n"

src/backend/locale/en_US/LC_MESSAGES/django.po

@@ -3,7 +3,7 @@ msgstr ""
 "Project-Id-Version: la-suite-conversations\n"
 "Report-Msgid-Bugs-To: \n"
 "POT-Creation-Date: 2025-10-20 21:48+0000\n"
-"PO-Revision-Date: 2025-11-10 12:20\n"
+"PO-Revision-Date: 2025-12-15 13:49\n"
 "Last-Translator: \n"
 "Language-Team: English\n"
 "Language: en_US\n"

src/backend/locale/fr_FR/LC_MESSAGES/django.po

@@ -3,7 +3,7 @@ msgstr ""
 "Project-Id-Version: la-suite-conversations\n"
 "Report-Msgid-Bugs-To: \n"
 "POT-Creation-Date: 2025-10-20 21:48+0000\n"
-"PO-Revision-Date: 2025-11-10 12:20\n"
+"PO-Revision-Date: 2025-12-15 13:49\n"
 "Last-Translator: \n"
 "Language-Team: French\n"
 "Language: fr_FR\n"

src/backend/locale/nl_NL/LC_MESSAGES/django.po

@@ -3,7 +3,7 @@ msgstr ""
 "Project-Id-Version: la-suite-conversations\n"
 "Report-Msgid-Bugs-To: \n"
 "POT-Creation-Date: 2025-10-20 21:48+0000\n"
-"PO-Revision-Date: 2025-11-10 12:20\n"
+"PO-Revision-Date: 2025-12-15 13:49\n"
 "Last-Translator: \n"
 "Language-Team: Dutch\n"
 "Language: nl_NL\n"

src/backend/locale/ru_RU/LC_MESSAGES/django.po

@@ -3,7 +3,7 @@ msgstr ""
 "Project-Id-Version: la-suite-conversations\n"
 "Report-Msgid-Bugs-To: \n"
 "POT-Creation-Date: 2025-10-20 21:48+0000\n"
-"PO-Revision-Date: 2025-11-10 12:20\n"
+"PO-Revision-Date: 2025-12-15 13:49\n"
 "Last-Translator: \n"
 "Language-Team: Russian\n"
 "Language: ru_RU\n"

src/backend/locale/uk_UA/LC_MESSAGES/django.po

@@ -3,7 +3,7 @@ msgstr ""
 "Project-Id-Version: la-suite-conversations\n"
 "Report-Msgid-Bugs-To: \n"
 "POT-Creation-Date: 2025-10-20 21:48+0000\n"
-"PO-Revision-Date: 2025-11-10 12:20\n"
+"PO-Revision-Date: 2025-12-15 13:49\n"
 "Last-Translator: \n"
 "Language-Team: Ukrainian\n"
 "Language: uk_UA\n"

src/backend/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "conversations"
-version = "0.0.8"
+version = "0.0.10"
 authors = [{ "name" = "DINUM", "email" = "dev@mail.numerique.gouv.fr" }]
 classifiers = [
     "Development Status :: 5 - Production/Stable",
@@ -27,19 +27,19 @@ requires-python = ">=3.12"
 dependencies = [
     "deprecated",
     "beautifulsoup4==4.14.2",
-    "boto3==1.40.67",
+    "boto3==1.40.73",
     "Brotli==1.2.0",
     "django-configurations==2.5.1",
     "django-cors-headers==4.9.0",
-    "django-countries==8.0.0",
+    "django-countries==8.1.0",
     "django-filter==25.2",
-    "django-lasuite[all]==0.0.17",
+    "django-lasuite[all]==0.0.18",
     "django-parler==2.3",
-    "django-pydantic-field==0.3.13",
+    "django-pydantic-field==0.4.0",
     "django-redis==6.0.0",
     "django-storages[s3]==1.14.6",
     "django-timezone-field>=5.1",
-    "django==5.2.8",
+    "django==5.2.9",
     "djangorestframework==3.16.1",
     "drf_spectacular==0.29.0",
     "dockerflow==2024.4.2",
@@ -47,22 +47,26 @@ dependencies = [
     "factory_boy==3.3.3",
     "gunicorn==23.0.0",
     "jsonschema==4.25.1",
-    "langfuse==3.9.0",
+    "langfuse==3.10.0",
     "lxml==5.4.0",
     "markdown==3.10",
     "markitdown==0.0.2",
     "mozilla-django-oidc==4.0.1",
     "nested-multipart-parser==1.6.0",
-    "posthog==6.8.0",
+    "matplotlib==3.9.2",
+    "numpy==2.1.3",
+    "openpyxl==3.1.5",
+    "pandas==2.2.3",
+    "posthog==7.0.0",
     "pydantic==2.12.4",
-    "pydantic-ai-slim[openai,mistral,mcp,evals,logfire]==1.11.0",
+    "pydantic-ai-slim[openai,mistral,mcp,evals,logfire]==1.17.0",
     "psycopg[binary]==3.2.12",
     "PyJWT==2.10.1",
     "python-magic==0.4.27",
     "redis<6.0.0",
     "requests==2.32.5",
     "semchunk==3.2.5",
-    "sentry-sdk==2.43.0",
+    "sentry-sdk==2.44.0",
     "trafilatura==2.0.0",
     "uvicorn==0.38.0",
     "whitenoise==6.11.0",
@@ -87,15 +91,15 @@ dev = [
     "pylint-django==2.6.1",
     "pylint==3.3.9",
     "pylint-pydantic==0.4.1",
-    "pytest-asyncio==1.2.0",
+    "pytest-asyncio==1.3.0",
     "pytest-cov==7.0.0",
     "pytest-django==4.11.1",
-    "pytest==8.4.2",
+    "pytest==9.0.1",
     "pytest-icdiff==0.9",
     "pytest-xdist==3.8.0",
     "responses==0.25.8",
     "respx==0.22.0",
-    "ruff==0.14.3",
+    "ruff==0.14.5",
     "types-requests==2.32.4.20250913",
 ]
 

src/frontend/apps/conversations/package.json

@@ -1,6 +1,6 @@
 {
   "name": "app-conversations",
-  "version": "0.0.8",
+  "version": "0.0.10",
   "private": true,
   "scripts": {
     "dev": "next dev",
@@ -36,16 +36,16 @@
     "i18next-browser-languagedetector": "8.1.0",
     "idb": "8.0.3",
     "lodash": "4.17.21",
+    "lottie-react": "^2.4.1",
     "luxon": "3.6.1",
     "micromark-extension-llm-math": "3.1.1-20250610",
-    "next": "15.3.3",
+    "next": "15.3.8",
     "posthog-js": "1.249.3",
-    "react": "*",
+    "react": "19.2.1",
     "react-aria-components": "1.9.0",
-    "react-dom": "18.3.1",
+    "react-dom": "19.2.1",
     "react-i18next": "15.5.2",
     "react-intersection-observer": "9.16.0",
-    "react-lottie": "^1.2.10",
     "react-markdown": "10.1.0",
     "react-select": "5.10.1",
     "rehype-katex": "7.0.1",

src/frontend/apps/conversations/src/components/DropdownMenu.tsx

@@ -1,4 +1,4 @@
-import { PropsWithChildren, useRef, useState } from 'react';
+import { PropsWithChildren, useEffect, useRef, useState } from 'react';
 import { css } from 'styled-components';
 
 import { Box, BoxButton, BoxProps, DropButton, Icon, Text } from '@/components';
@@ -35,8 +35,16 @@ export const DropdownMenu = ({
 }: PropsWithChildren<DropdownMenuProps>) => {
   const { spacingsTokens, colorsTokens } = useCunninghamTheme();
   const [isOpen, setIsOpen] = useState(false);
+  const [buttonWidth, setButtonWidth] = useState<number | undefined>(undefined);
   const blockButtonRef = useRef<HTMLDivElement>(null);
 
+  useEffect(() => {
+    // Mettre à jour la largeur uniquement côté client
+    if (blockButtonRef.current) {
+      setButtonWidth(blockButtonRef.current.clientWidth);
+    }
+  }, [isOpen]);
+
   const onOpenChange = (isOpen: boolean) => {
     setIsOpen(isOpen);
   };
@@ -76,7 +84,7 @@ export const DropdownMenu = ({
     >
       <Box
         $maxWidth="320px"
-        $minWidth={`${blockButtonRef.current?.clientWidth}px`}
+        $minWidth={buttonWidth ? `${buttonWidth}px` : undefined}
         role="menu"
       >
         {topMessage && (

src/frontend/apps/conversations/src/components/Loader.tsx

@@ -1,20 +1,17 @@
-import Lottie from 'react-lottie';
+import dynamic from 'next/dynamic';
 
+const Lottie = dynamic(() => import('lottie-react'), { ssr: false });
 import searchingAnimation from '@/assets/lotties/searching';
 
-export const Loader = () => {
-  const LoaderOptions = {
-    loop: true,
-    autoplay: true,
-    animationData: searchingAnimation,
-    rendererSettings: {
-      preserveAspectRatio: 'xMidYMid slice',
-    },
-  } as const;
-
+export function Loader() {
   return (
-    <div>
-      <Lottie options={LoaderOptions} height={24} width={24} />
+    <div role="status">
+      <Lottie
+        animationData={searchingAnimation}
+        loop
+        autoplay
+        style={{ width: 24, height: 24 }}
+      />
     </div>
   );
-};
+}

src/frontend/apps/conversations/src/components/ToastProvider.tsx

@@ -3,6 +3,7 @@ import {
   createContext,
   useCallback,
   useContext,
+  useEffect,
   useState,
 } from 'react';
 import { createPortal } from 'react-dom';
@@ -47,6 +48,11 @@ interface ToastProviderProps {
 
 export const ToastProvider = ({ children }: ToastProviderProps) => {
   const [toasts, setToasts] = useState<ToastItem[]>([]);
+  const [isMounted, setIsMounted] = useState(false);
+
+  useEffect(() => {
+    setIsMounted(true);
+  }, []);
 
   const showToast = useCallback(
     (
@@ -83,7 +89,9 @@ export const ToastProvider = ({ children }: ToastProviderProps) => {
   return (
     <ToastContext.Provider value={value}>
       {children}
-      {typeof window !== 'undefined' &&
+      {isMounted &&
+        typeof document !== 'undefined' &&
+        document.body &&
         createPortal(
           <Box
             aria-live="polite"

src/frontend/apps/conversations/src/core/AppProvider.tsx

@@ -1,74 +1,64 @@
-import { CunninghamProvider } from '@openfun/cunningham-react';
 import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
-import { useRouter } from 'next/router';
+import dynamic from 'next/dynamic';
 import { useEffect } from 'react';
 
-import { ToastProvider } from '@/components';
 import { useCunninghamTheme } from '@/cunningham';
 import { Auth, KEY_AUTH, setAuthUrl } from '@/features/auth';
-import { useResponsiveStore } from '@/stores/';
+import { useResponsiveStore } from '@/stores';
 
-import { ConfigProvider } from './config/';
+import { ConfigProvider } from './config';
+
+// Client-only providers
+const ToastProviderNoSSR = dynamic(
+  () => import('@/components').then((mod) => ({ default: mod.ToastProvider })),
+  { ssr: false, loading: () => null },
+);
+
+const CunninghamProviderNoSSR = dynamic(
+  () =>
+    import('@openfun/cunningham-react').then((mod) => ({
+      default: mod.CunninghamProvider,
+    })),
+  { ssr: false },
+);
 
-/**
- * QueryClient:
- *  - defaultOptions:
- *    - staleTime:
- *      - global cache duration - we decided 3 minutes
- *      - It can be overridden to each query
- */
-const defaultOptions = {
-  queries: {
-    staleTime: 1000 * 60 * 3,
-    retry: 1,
-  },
-};
 const queryClient = new QueryClient({
-  defaultOptions,
+  defaultOptions: {
+    queries: { staleTime: 1000 * 60 * 3, retry: 1 },
+    mutations: {
+      onError: (error) => {
+        if (
+          error instanceof Error &&
+          'status' in error &&
+          error.status === 401
+        ) {
+          void queryClient.resetQueries({ queryKey: [KEY_AUTH] });
+          setAuthUrl();
+          if (typeof window !== 'undefined') {
+            window.location.href = '/401';
+          }
+        }
+      },
+    },
+  },
 });
 
 export function AppProvider({ children }: { children: React.ReactNode }) {
-  const { theme } = useCunninghamTheme();
-  const { replace } = useRouter();
-
-  const initializeResizeListener = useResponsiveStore(
-    (state) => state.initializeResizeListener,
-  );
+  const theme = useCunninghamTheme((state) => state.theme);
 
   useEffect(() => {
-    return initializeResizeListener();
-  }, [initializeResizeListener]);
-
-  useEffect(() => {
-    queryClient.setDefaultOptions({
-      ...defaultOptions,
-      mutations: {
-        onError: (error) => {
-          if (
-            error instanceof Error &&
-            'status' in error &&
-            error.status === 401
-          ) {
-            void queryClient.resetQueries({
-              queryKey: [KEY_AUTH],
-            });
-            setAuthUrl();
-            void replace(`/401`);
-          }
-        },
-      },
-    });
-  }, [replace]);
+    return useResponsiveStore.getState().initializeResizeListener();
+  }, []);
 
   return (
     <QueryClientProvider client={queryClient}>
-      <CunninghamProvider theme={theme}>
+      <CunninghamProviderNoSSR theme={theme}>
         <ConfigProvider>
-          <ToastProvider>
+          <ToastProviderNoSSR>
             <Auth>{children}</Auth>
-          </ToastProvider>
+          </ToastProviderNoSSR>
         </ConfigProvider>
-      </CunninghamProvider>
+      </CunninghamProviderNoSSR>
     </QueryClientProvider>
   );
 }

src/frontend/apps/conversations/src/features/chat/components/AttachmentList.tsx

@@ -55,7 +55,7 @@ export const AttachmentList = ({
           >
             <Box
               $background="var(--c--theme--colors--greyscale-050)"
-              $minWidth="200px"
+              $width="200px"
               $direction="row"
               $gap="8px"
               $align="center"

src/frontend/apps/conversations/src/features/chat/components/Chat.tsx

@@ -8,6 +8,7 @@ import { Modal, ModalSize } from '@openfun/cunningham-react';
 import 'katex/dist/katex.min.css'; // `rehype-katex` does not import the CSS for you
 import { useRouter } from 'next/router';
 import { useCallback, useEffect, useRef, useState } from 'react';
+import type { ChangeEvent, FormEvent } from 'react';
 import { useTranslation } from 'react-i18next';
 import { MarkdownHooks } from 'react-markdown';
 import rehypeKatex from 'rehype-katex';
@@ -16,7 +17,7 @@ import remarkGfm from 'remark-gfm';
 import remarkMath from 'remark-math';
 
 import { APIError, errorCauses, fetchAPI } from '@/api';
-import { Box, Icon, Loader, StyledLink, Text } from '@/components';
+import { Box, Icon, Loader, Text } from '@/components';
 import { useUploadFile } from '@/features/attachments/hooks/useUploadFile';
 import { useChat } from '@/features/chat/api/useChat';
 import { getConversation } from '@/features/chat/api/useConversation';
@@ -26,6 +27,8 @@ import {
   useLLMConfiguration,
 } from '@/features/chat/api/useLLMConfiguration';
 import { AttachmentList } from '@/features/chat/components/AttachmentList';
+import { ChatError } from '@/features/chat/components/ChatError';
+import { CodeBlock } from '@/features/chat/components/CodeBlock';
 import { FeedbackButtons } from '@/features/chat/components/FeedbackButtons';
 import { InputChat } from '@/features/chat/components/InputChat';
 import { SourceItemList } from '@/features/chat/components/SourceItemList';
@@ -101,19 +104,14 @@ export const Chat = ({
 
       if (modelToSelect) {
         setSelectedModel(modelToSelect);
+        setSelectedModelHrid(modelToSelect.hrid);
       }
     }
-  }, [llmConfig, selectedModel, selectedModelHrid]);
-
-  // Update store when model selection changes
-  useEffect(() => {
-    if (selectedModel?.hrid !== selectedModelHrid) {
-      setSelectedModelHrid(selectedModel?.hrid || null);
-    }
-  }, [selectedModel, selectedModelHrid, setSelectedModelHrid]);
+  }, [llmConfig, selectedModel, selectedModelHrid, setSelectedModelHrid]);
 
   const handleModelSelect = (model: LLMModel) => {
     setSelectedModel(model);
+    setSelectedModelHrid(model.hrid);
   };
 
   const router = useRouter();
@@ -153,17 +151,26 @@ export const Chat = ({
   const [initialConversationMessages, setInitialConversationMessages] =
     useState<Message[] | undefined>(undefined);
   const [pendingFirstMessage, setPendingFirstMessage] = useState<{
-    event: React.FormEvent<HTMLFormElement>;
+    event: FormEvent<HTMLFormElement>;
     attachments?: Attachment[];
     forceWebSearch?: boolean;
   } | null>(null);
   const [shouldAutoSubmit, setShouldAutoSubmit] = useState(false);
+  const [shouldRetry, setShouldRetry] = useState(false);
+  const retryOriginalInputRef = useRef<string>('');
+  const retryOriginalFilesRef = useRef<FileList | null>(null);
   const [hasInitialized, setHasInitialized] = useState(false);
   const [streamingMessageHeight, setStreamingMessageHeight] = useState<
     number | null
   >(null);
   const lastUserMessageIdRef = useRef<string | null>(null);
   const hasScrolledToBottomOnLoadRef = useRef(false);
+  const lastSubmissionRef = useRef<{
+    input: string;
+    files: FileList | null;
+    event: FormEvent<HTMLFormElement>;
+    options?: Record<string, unknown>;
+  } | null>(null);
 
   const { mutate: createChatConversation } = useCreateChatConversation();
 
@@ -212,6 +219,7 @@ export const Chat = ({
     handleInputChange,
     status,
     stop: stopChat,
+    setMessages,
   } = useChat({
     id: conversationId,
     initialMessages: initialConversationMessages,
@@ -244,10 +252,33 @@ export const Chat = ({
     void stopGeneration();
   };
 
-  const handleSubmitWrapper = (event: React.FormEvent<HTMLFormElement>) => {
+  const handleSubmitWrapper = (event: FormEvent<HTMLFormElement>) => {
     void handleSubmit(event);
   };
 
+  const handleRetry = () => {
+    if (!lastSubmissionRef.current || !setMessages) {
+      return;
+    }
+
+    const { input: lastInput, files: lastFiles } = lastSubmissionRef.current;
+
+    const lastAssistantIndex = messages.findLastIndex(
+      (msg) => msg.role === 'assistant',
+    );
+    if (lastAssistantIndex !== -1) {
+      setMessages(messages.filter((_, index) => index !== lastAssistantIndex));
+    }
+
+    retryOriginalInputRef.current = input;
+    retryOriginalFilesRef.current = files;
+    handleInputChange({
+      target: { value: lastInput },
+    } as ChangeEvent<HTMLTextAreaElement>);
+    setFiles(lastFiles);
+    setShouldRetry(true);
+  };
+
   // Précharger les métadonnées des sources dès que les messages arrivent
   useEffect(() => {
     messages.forEach((message) => {
@@ -260,7 +291,8 @@ export const Chat = ({
         });
       }
     });
-  }, [messages, prefetchMetadata]);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [messages]);
 
   const openSources = (messageId: string) => {
     if (isSourceOpen === messageId) {
@@ -303,16 +335,23 @@ export const Chat = ({
 
           const availableHeight = containerHeight - userMessageHeight - 38;
 
-          if (streamingMessageHeight !== availableHeight) {
-            setStreamingMessageHeight(availableHeight);
-          }
+          setStreamingMessageHeight((prev) => {
+            if (prev === null || Math.abs(prev - availableHeight) > 10) {
+              return availableHeight;
+            }
+            return prev;
+          });
         }
       }
     }
-  }, [messages, streamingMessageHeight]);
+  }, [messages]);
 
   // Détecter l'arrivée d'un nouveau message user et retirer la hauteur de l'ancien
   useEffect(() => {
+    if (status === 'streaming') {
+      return;
+    }
+
     const userMessages = messages.filter((msg) => msg.role === 'user');
     const lastUserMessage = userMessages[userMessages.length - 1];
 
@@ -325,14 +364,14 @@ export const Chat = ({
       }
       lastUserMessageIdRef.current = lastUserMessage.id;
     }
-  }, [messages]);
+  }, [messages, status]);
 
-  // Calculer la hauteur pendant submitted/streaming
   useEffect(() => {
     if (status === 'submitted' || status === 'streaming') {
       calculateStreamingHeight();
     }
-  }, [status, calculateStreamingHeight]);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [status]);
 
   // Scroller vers la question au moment du submit
   useEffect(() => {
@@ -352,7 +391,8 @@ export const Chat = ({
 
       messageElement?.scrollIntoView({ block: 'start', behavior: 'smooth' });
     });
-  }, [status, messages]);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [status]);
 
   // Synchronize conversationId state with prop when it changes (e.g., after navigation)
   useEffect(() => {
@@ -361,10 +401,11 @@ export const Chat = ({
     if (initialConversationId !== conversationId) {
       handleInputChange({
         target: { value: '' },
-      } as React.ChangeEvent<HTMLTextAreaElement>);
+      } as ChangeEvent<HTMLTextAreaElement>);
       setHasInitialized(false); // Réinitialiser pour permettre le scroll au prochain chargement
     }
-  }, [initialConversationId, conversationId, handleInputChange]);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [initialConversationId, conversationId]);
 
   // On mount, if there is pending input/files, initialize state and set flag
   useEffect(() => {
@@ -375,7 +416,7 @@ export const Chat = ({
       if (pendingInput) {
         const syntheticEvent = {
           target: { value: pendingInput },
-        } as React.ChangeEvent<HTMLInputElement>;
+        } as ChangeEvent<HTMLInputElement>;
         handleInputChange(syntheticEvent);
       }
       if (pendingFiles) {
@@ -397,13 +438,32 @@ export const Chat = ({
       const syntheticFormEvent = {
         preventDefault: () => {},
         target: form,
-      } as unknown as React.FormEvent<HTMLFormElement>;
+      } as unknown as FormEvent<HTMLFormElement>;
       void handleSubmit(syntheticFormEvent);
       setShouldAutoSubmit(false);
     }
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [shouldAutoSubmit, input, files]);
 
+  useEffect(() => {
+    if (
+      shouldRetry &&
+      lastSubmissionRef.current &&
+      input === lastSubmissionRef.current.input
+    ) {
+      const { event } = lastSubmissionRef.current;
+
+      void handleSubmit(event);
+      handleInputChange({
+        target: { value: retryOriginalInputRef.current },
+      } as ChangeEvent<HTMLTextAreaElement>);
+      setFiles(retryOriginalFilesRef.current);
+
+      setShouldRetry(false);
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [shouldRetry, input, files]);
+
   // Fetch initial conversation messages if initialConversationId is provided and no pending input
   useEffect(() => {
     hasScrolledToBottomOnLoadRef.current = false; // Réinitialiser au début du chargement
@@ -457,7 +517,7 @@ export const Chat = ({
   }, [hasInitialized, messages.length]);
 
   // Custom handleSubmit to include attachments and handle chat creation
-  const handleSubmit = async (event: React.FormEvent<HTMLFormElement>) => {
+  const handleSubmit = async (event: FormEvent<HTMLFormElement>) => {
     event.preventDefault();
 
     // Upload files to server and get URLs
@@ -536,6 +596,13 @@ export const Chat = ({
       options.experimental_attachments = attachments;
     }
 
+    lastSubmissionRef.current = {
+      input,
+      files,
+      event,
+      options: Object.keys(options).length > 0 ? options : undefined,
+    };
+
     if (Object.keys(options).length > 0) {
       baseHandleSubmit(event, options);
     } else {
@@ -642,6 +709,11 @@ export const Chat = ({
                       {message.content && (
                         <Box
                           className="mainContent-chat"
+                          data-testid={
+                            message.role === 'assistant'
+                              ? 'assistant-message-content'
+                              : undefined
+                          }
                           $padding={{ all: 'xxs' }}
                         >
                           <p className="sr-only">
@@ -649,38 +721,53 @@ export const Chat = ({
                               ? t('You said: ')
                               : t('Assistant IA replied: ')}
                           </p>
-                          <MarkdownHooks
-                            remarkPlugins={[remarkGfm, remarkMath]}
-                            rehypePlugins={[
-                              [
-                                rehypePrettyCode,
-                                {
-                                  theme: 'github-dark-dimmed',
-                                },
-                              ],
-                              rehypeKatex,
-                            ]}
-                            components={{
-                              // Custom components for Markdown rendering
-                              // eslint-disable-next-line @typescript-eslint/no-unused-vars
-                              p: ({ node, ...props }) => (
-                                <Text
-                                  as="p"
-                                  $css="display: block"
-                                  $theme="greyscale"
-                                  $variation="850"
-                                  {...props}
-                                />
-                              ),
-                              a: ({ children, ...props }) => (
-                                <a target="_blank" {...props}>
-                                  {children}
-                                </a>
-                              ),
-                            }}
-                          >
-                            {message.content}
-                          </MarkdownHooks>
+                          {message.role === 'user' ? (
+                            <Text
+                              as="p"
+                              $css="white-space: pre-wrap; display: block;"
+                              $theme="greyscale"
+                              $variation="850"
+                            >
+                              {message.content}
+                            </Text>
+                          ) : (
+                            <MarkdownHooks
+                              remarkPlugins={[remarkGfm, remarkMath]}
+                              rehypePlugins={[
+                                [
+                                  rehypePrettyCode,
+                                  {
+                                    theme: 'github-dark-dimmed',
+                                  },
+                                ],
+                                rehypeKatex,
+                              ]}
+                              components={{
+                                // Custom components for Markdown rendering
+                                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                                p: ({ node, ...props }) => (
+                                  <Text
+                                    as="p"
+                                    $css="display: block"
+                                    $theme="greyscale"
+                                    $variation="850"
+                                    {...props}
+                                  />
+                                ),
+                                a: ({ children, ...props }) => (
+                                  <a target="_blank" {...props}>
+                                    {children}
+                                  </a>
+                                ),
+                                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                                pre: ({ node, children, ...props }) => (
+                                  <CodeBlock {...props}>{children}</CodeBlock>
+                                ),
+                              }}
+                            >
+                              {message.content}
+                            </MarkdownHooks>
+                          )}
                         </Box>
                       )}
 
@@ -913,27 +1000,11 @@ export const Chat = ({
             </Text>
           </Box>
         ) : null}
-        {status === 'error' && (
-          <Box
-            $direction={isMobile ? 'column' : 'row'}
-            $gap="6px"
-            $width="100%"
-            $maxWidth="750px"
-            $margin={{ all: 'auto', top: 'base', bottom: 'md' }}
-            $padding={{ left: '13px' }}
-          >
-            <Text>{t('Sorry, an error occurred. Please try again.')}</Text>
-            <StyledLink
-              href="/"
-              rel="noopener noreferrer"
-              $css={`
-              color: var(--c--theme--colors--greyscale-900);
-              text-decoration: underline;
-            `}
-            >
-              {t('Start a new conversation.')}
-            </StyledLink>
-          </Box>
+        {status === 'error' && !isUploadingFiles && (
+          <ChatError
+            hasLastSubmission={!!lastSubmissionRef.current}
+            onRetry={handleRetry}
+          />
         )}
       </Box>
       <Box
@@ -941,6 +1012,7 @@ export const Chat = ({
           position: relative;
           bottom: ${isMobile ? '8px' : '20px'};
           margin: auto;
+          background-color: white;
           z-index: 1000;
         `}
         $gap="6px"

src/frontend/apps/conversations/src/features/chat/components/ChatError.tsx

@@ -0,0 +1,80 @@
+import { Button } from '@openfun/cunningham-react';
+import { useRouter } from 'next/router';
+import { useTranslation } from 'react-i18next';
+
+import { Box, Icon, Text } from '@/components';
+
+interface ChatErrorProps {
+  hasLastSubmission: boolean;
+  onRetry: () => void;
+}
+
+export const ChatError = ({ hasLastSubmission, onRetry }: ChatErrorProps) => {
+  const { t } = useTranslation();
+  const router = useRouter();
+
+  return (
+    <Box
+      $direction="column"
+      $gap="6px"
+      $width="100%"
+      $maxWidth="750px"
+      $margin={{ all: 'auto', top: 'base', bottom: 'md' }}
+      $padding={{ left: '13px' }}
+    >
+      <Text $variation="550" $theme="greyscale">
+        {t('Sorry, an error occurred. Please try again.')}
+      </Text>
+      <Box
+        $direction="row"
+        $gap="6px"
+        $align="center"
+        $margin={{ top: '10px' }}
+      >
+        {hasLastSubmission ? (
+          <Button
+            size="small"
+            color="tertiary"
+            onClick={onRetry}
+            className="retry-button"
+            style={{
+              color: 'var(--c--theme--colors--greyscale-550)',
+              borderColor: 'var(--c--theme--colors--greyscale-300)',
+            }}
+            icon={
+              <svg
+                xmlns="http://www.w3.org/2000/svg"
+                width="11"
+                height="15"
+                viewBox="0 0 11 15"
+                fill="none"
+              >
+                <path
+                  d="M0.733333 10.0333C0.488889 9.61111 0.305556 9.17778 0.183333 8.73333C0.0611111 8.28889 0 7.83333 0 7.36667C0 5.87778 0.516667 4.61111 1.55 3.56667C2.58333 2.52222 3.84444 2 5.33333 2H5.45L4.38333 0.933333L5.31667 0L7.98333 2.66667L5.31667 5.33333L4.38333 4.4L5.45 3.33333H5.33333C4.22222 3.33333 3.27778 3.725 2.5 4.50833C1.72222 5.29167 1.33333 6.24444 1.33333 7.36667C1.33333 7.65556 1.36667 7.93889 1.43333 8.21667C1.5 8.49444 1.6 8.76667 1.73333 9.03333L0.733333 10.0333ZM5.35 14.6667L2.68333 12L5.35 9.33333L6.28333 10.2667L5.21667 11.3333H5.33333C6.44444 11.3333 7.38889 10.9417 8.16667 10.1583C8.94444 9.375 9.33333 8.42222 9.33333 7.3C9.33333 7.01111 9.3 6.72778 9.23333 6.45C9.16667 6.17222 9.06667 5.9 8.93333 5.63333L9.93333 4.63333C10.1778 5.05556 10.3611 5.48889 10.4833 5.93333C10.6056 6.37778 10.6667 6.83333 10.6667 7.3C10.6667 8.78889 10.15 10.0556 9.11667 11.1C8.08333 12.1444 6.82222 12.6667 5.33333 12.6667H5.21667L6.28333 13.7333L5.35 14.6667Z"
+                  fill="currentColor"
+                />
+              </svg>
+            }
+          >
+            {t('Retry')}
+          </Button>
+        ) : (
+          <Button
+            size="small"
+            color="tertiary"
+            style={{
+              color: 'var(--c--theme--colors--greyscale-550)',
+              borderColor: 'var(--c--theme--colors--greyscale-300)',
+            }}
+            onClick={() => {
+              void router.push('/');
+            }}
+            icon={<Icon iconName="add" $color="greyscale" />}
+          >
+            {t('Start a new conversation')}
+          </Button>
+        )}
+      </Box>
+    </Box>
+  );
+};

src/frontend/apps/conversations/src/features/chat/components/CodeBlock.tsx

@@ -0,0 +1,80 @@
+import { useRef } from 'react';
+import type { ReactNode } from 'react';
+import { useTranslation } from 'react-i18next';
+
+import { Box, Icon, Text } from '@/components';
+import { useClipboard } from '@/hook';
+
+interface CopyCodeButtonProps {
+  onCopy: () => void;
+}
+
+const CopyCodeButton = ({ onCopy }: CopyCodeButtonProps) => {
+  const { t } = useTranslation();
+
+  return (
+    <Box
+      as="button"
+      onClick={onCopy}
+      $css={`
+        position: absolute;
+        top: 8px;
+        right: 8px;
+        padding: 6px 10px;
+        background: rgba(0, 0, 0, 0.03);
+        border: 1px solid rgba(255, 255, 255, 0.15);
+        border-radius: 4px;
+        cursor: pointer;
+        font-size: 12px;
+        font-weight: 500;
+        color: #fff;
+        display: flex;
+        flex-direction: row;
+        align-items: center;
+        gap: 4px;
+        z-index: 10;
+        transition: all 0.2s;
+        box-shadow: 0 1px 2px rgba(0, 0, 0, 0.1);
+        width: fit-content;
+        &:hover {
+          background:rgba(255, 255, 255, 0.1);
+          border: 1px solid rgba(255, 255, 255, 0.20);
+        }
+      `}
+    >
+      <Icon
+        iconName="content_copy"
+        $size="14px"
+        $theme="greyscale"
+        $variation="200"
+      />
+      <Text $size="xs" $theme="greyscale" $variation="200">
+        {t('Copy code')}
+      </Text>
+    </Box>
+  );
+};
+
+interface CodeBlockProps {
+  children: ReactNode;
+  [key: string]: unknown;
+}
+
+export const CodeBlock = ({ children, ...props }: CodeBlockProps) => {
+  const preRef = useRef<HTMLPreElement>(null);
+  const copyToClipboard = useClipboard();
+
+  const handleCopy = () => {
+    const code = preRef.current?.querySelector('code');
+    copyToClipboard(code?.textContent || '');
+  };
+
+  return (
+    <>
+      <CopyCodeButton onCopy={handleCopy} />
+      <Box ref={preRef} $position="relative" as="pre" {...props}>
+        {children}
+      </Box>
+    </>
+  );
+};

src/frontend/apps/conversations/src/features/chat/components/InputChat.tsx

@@ -300,7 +300,6 @@ export const InputChat = ({
         $css={`
         display: block;
         position: relative;
-        opacity: ${status === 'error' ? '0.5' : '1'};
         margin: auto;
         width: 100%;
         padding: ${isDesktop ? '0' : '0 10px'};
@@ -308,26 +307,22 @@ export const InputChat = ({
       `}
       >
         {/* Bouton de scroll vers le bas */}
-        {messagesLength > 1 &&
-          status !== 'streaming' &&
-          status !== 'submitted' &&
-          containerRef &&
-          onScrollToBottom && (
-            <Box
-              $css={`
+        {messagesLength > 1 && containerRef && onScrollToBottom && (
+          <Box
+            $css={`
             position: relative;
             height: 0;
             width: 100%;
             margin: auto;
             max-width: 750px;
           `}
-            >
-              <ScrollDown
-                onClick={onScrollToBottom}
-                containerRef={containerRef}
-              />
-            </Box>
-          )}
+          >
+            <ScrollDown
+              onClick={onScrollToBottom}
+              containerRef={containerRef}
+            />
+          </Box>
+        )}
         {/* Message de bienvenue */}
         {messagesLength === 0 && (
           <Box
@@ -423,6 +418,7 @@ export const InputChat = ({
                   fontSize: '1rem',
                   border: 'none',
                   resize: 'none',
+                  opacity: status === 'error' ? '0.5' : '1',
                   fontFamily: 'inherit',
                   minHeight: '64px',
                   maxHeight: '200px',
@@ -573,6 +569,9 @@ export const InputChat = ({
                 $gap="sm"
                 $padding={{ bottom: 'base' }}
                 $align="space-between"
+                $css={`
+                opacity: ${status === 'error' ? '0.5' : '1'};
+                `}
               >
                 <Box
                   $flex="1"

src/frontend/apps/conversations/src/features/chat/components/ToolInvocationItem.tsx

@@ -40,7 +40,7 @@ export const ToolInvocationItem: React.FC<ToolInvocationItemProps> = ({
         $color="var(--c--theme--colors--greyscale-500)"
         $padding={{ all: 'sm' }}
         $radius="8px"
-        $css="font-size: 0.9em;"
+        $css="font-size: 0.9em; width: 100%; white-space: pre-wrap; word-wrap: break-word;"
       >
         {toolInvocation.state === 'result' ? (
           <Text>{`Parsing done: ${documentIdentifiers.join(', ')}`}</Text>

src/frontend/apps/conversations/src/features/chat/hooks/useSourceMetadata.ts

@@ -1,4 +1,4 @@
-import { useState } from 'react';
+import { useCallback, useRef, useState } from 'react';
 
 interface SourceMetadata {
   title: string | null;
@@ -9,109 +9,124 @@ interface SourceMetadata {
 
 // Cache global pour éviter de refetch les mêmes URLs
 const metadataCache = new Map<string, SourceMetadata>();
+const fetchingUrls = new Set<string>();
 
 export const useSourceMetadataCache = () => {
-  const [cache, setCache] =
-    useState<Map<string, SourceMetadata>>(metadataCache);
+  const [, forceUpdate] = useState({});
+  const updateCountRef = useRef(0);
 
-  const prefetchMetadata = async (url: string) => {
-    // Si déjà en cache, ne rien faire
-    if (metadataCache.has(url)) {
-      return;
+  const triggerUpdate = useCallback(() => {
+    updateCountRef.current++;
+    if (updateCountRef.current % 5 === 0) {
+      forceUpdate({});
     }
+  }, []);
 
-    // Marquer comme en cours de chargement
-    metadataCache.set(url, {
-      title: null,
-      favicon: null,
-      loading: true,
-      error: false,
-    });
-    setCache(new Map(metadataCache));
-
-    try {
-      if (!url.startsWith('http')) {
-        metadataCache.set(url, {
-          title: url,
-          favicon: '📄',
-          loading: false,
-          error: false,
-        });
-        setCache(new Map(metadataCache));
+  const prefetchMetadata = useCallback(
+    async (url: string) => {
+      if (metadataCache.has(url) || fetchingUrls.has(url)) {
         return;
       }
 
-      const parser = new DOMParser();
+      fetchingUrls.add(url);
+
+      metadataCache.set(url, {
+        title: null,
+        favicon: null,
+        loading: true,
+        error: false,
+      });
+      triggerUpdate();
 
-      let response;
       try {
-        response = await fetch(url, {
-          mode: 'cors',
-          headers: {
-            'User-Agent': 'Mozilla/5.0 (compatible; ChatBot/1.0)',
-          },
+        if (!url.startsWith('http')) {
+          metadataCache.set(url, {
+            title: url,
+            favicon: '📄',
+            loading: false,
+            error: false,
+          });
+          fetchingUrls.delete(url);
+          triggerUpdate();
+          return;
+        }
+
+        const parser = new DOMParser();
+
+        let response;
+        try {
+          response = await fetch(url, {
+            mode: 'cors',
+            headers: {
+              'User-Agent': 'Mozilla/5.0 (compatible; ChatBot/1.0)',
+            },
+          });
+        } catch {
+          // Si CORS échoue, utiliser juste le hostname
+          metadataCache.set(url, {
+            title: new URL(url).hostname,
+            favicon: null,
+            loading: false,
+            error: false,
+          });
+          fetchingUrls.delete(url);
+          triggerUpdate();
+          return;
+        }
+
+        if (!response.ok) {
+          throw new Error(`HTTP ${response.status}`);
+        }
+
+        const html = await response.text();
+        const doc = parser.parseFromString(html, 'text/html');
+
+        // Récupérer le titre
+        const pageTitle =
+          doc.querySelector('title')?.textContent || new URL(url).hostname;
+
+        // Récupérer le favicon
+        let faviconUrl =
+          doc.querySelector('link[rel="icon"]')?.getAttribute('href') ||
+          doc.querySelector('link[rel="shortcut icon"]')?.getAttribute('href');
+
+        if (!faviconUrl) {
+          const urlObj = new URL(url);
+          faviconUrl = `${urlObj.origin}/favicon.ico`;
+        }
+
+        // Convertir les URLs relatives en absolues
+        if (faviconUrl && !faviconUrl.startsWith('http')) {
+          const urlObj = new URL(url);
+          faviconUrl = new URL(faviconUrl, urlObj.origin).href;
+        }
+
+        metadataCache.set(url, {
+          title: pageTitle,
+          favicon: faviconUrl || null,
+          loading: false,
+          error: false,
         });
-      } catch {
-        // Si CORS échoue, utiliser juste le hostname
+        fetchingUrls.delete(url);
+        triggerUpdate();
+      } catch (err) {
+        console.log('Error fetching metadata for:', url, err);
         metadataCache.set(url, {
           title: new URL(url).hostname,
           favicon: null,
           loading: false,
-          error: false,
+          error: true,
         });
-        setCache(new Map(metadataCache));
-        return;
+        fetchingUrls.delete(url);
+        triggerUpdate();
       }
+    },
+    [triggerUpdate],
+  );
 
-      if (!response.ok) {
-        throw new Error(`HTTP ${response.status}`);
-      }
+  const getMetadata = useCallback((url: string): SourceMetadata | undefined => {
+    return metadataCache.get(url);
+  }, []);
 
-      const html = await response.text();
-      const doc = parser.parseFromString(html, 'text/html');
-
-      // Récupérer le titre
-      const pageTitle =
-        doc.querySelector('title')?.textContent || new URL(url).hostname;
-
-      // Récupérer le favicon
-      let faviconUrl =
-        doc.querySelector('link[rel="icon"]')?.getAttribute('href') ||
-        doc.querySelector('link[rel="shortcut icon"]')?.getAttribute('href');
-
-      if (!faviconUrl) {
-        const urlObj = new URL(url);
-        faviconUrl = `${urlObj.origin}/favicon.ico`;
-      }
-
-      // Convertir les URLs relatives en absolues
-      if (faviconUrl && !faviconUrl.startsWith('http')) {
-        const urlObj = new URL(url);
-        faviconUrl = new URL(faviconUrl, urlObj.origin).href;
-      }
-
-      metadataCache.set(url, {
-        title: pageTitle,
-        favicon: faviconUrl || null,
-        loading: false,
-        error: false,
-      });
-      setCache(new Map(metadataCache));
-    } catch (err) {
-      console.log('Error fetching metadata for:', url, err);
-      metadataCache.set(url, {
-        title: new URL(url).hostname,
-        favicon: null,
-        loading: false,
-        error: true,
-      });
-      setCache(new Map(metadataCache));
-    }
-  };
-
-  const getMetadata = (url: string): SourceMetadata | undefined => {
-    return cache.get(url);
-  };
-
-  return { prefetchMetadata, getMetadata, cache };
+  return { prefetchMetadata, getMetadata };
 };

src/frontend/apps/conversations/src/i18n/translations.json

@@ -35,6 +35,7 @@
       "Conversation analysis enabled": "Analyse de la conversation activée",
       "Copied": "Copié",
       "Copy": "Copier",
+      "Copy code": "Copier le code",
       "Default": "Par défaut",
       "Delete": "Supprimer",
       "Delete a conversation": "Supprimer une conversation",
@@ -59,7 +60,7 @@
       "Give feedback": "Faire un retour",
       "History": "Historique",
       "Home": "Accueil",
-      "If enabled, this allows us to analyse your exchanges to improve the Assistant. If disabled, all conversations remain confidential and are not used in any way. ": "Si cette option est activée, cela nous permet d'analyser vos conversations afin d'améliorer l'Assistant. Si elle est désactivée, toutes les conversations restent confidentielles et ne sont utilisées d'aucune manière ",
+      "If enabled, this allows us to analyse your exchanges to improve the Assistant. If disabled, all conversations remain confidential and are not used in any way. ": "Si cette option est activée, cela nous permet d'analyser vos conversations afin d'améliorer l'Assistant. Si elle est désactivée, toutes les conversations restent confidentielles et ne sont utilisées d'aucune manière. ",
       "Illustration": "Image",
       "Image 401": "Image 401",
       "Image 403": "Image 403",
@@ -166,6 +167,7 @@
       "Conversation analysis enabled": "Gespreksanalyse ingeschakeld",
       "Copied": "Gekopieerd",
       "Copy": "Kopiëren",
+      "Copy code": "Kopieer code",
       "Default": "Standaard",
       "Delete": "Verwijderen",
       "Delete a conversation": "Een gesprek verwijderen",
@@ -297,6 +299,7 @@
       "Conversation analysis enabled": "Анализ бесед включён",
       "Copied": "Скопировано",
       "Copy": "Копировать",
+      "Copy code": "Скопировать код",
       "Default": "По-умолчанию",
       "Delete": "Удалить",
       "Delete a conversation": "Удалить беседу",
@@ -428,6 +431,7 @@
       "Conversation analysis enabled": "Аналіз розмов увімкнено",
       "Copied": "Скопійовано",
       "Copy": "Копіювати",
+      "Copy code": "Скопіювати код",
       "Default": "За замовчуванням",
       "Delete": "Видалити",
       "Delete a conversation": "Видалити розмову",

src/frontend/apps/conversations/src/pages/globals.css

@@ -235,6 +235,7 @@ ul a:hover {
 figure[data-rehype-pretty-code-figure] {
   margin-left: 0;
   margin-right: 0;
+  position: relative;
 }
 
 figure[data-rehype-pretty-code-figure] > pre {

src/frontend/apps/e2e/__tests__/app-conversations/chat.spec.ts

@@ -0,0 +1,72 @@
+import { expect, test } from '@playwright/test';
+
+test.beforeEach(async ({ page }) => {
+  await page.goto('/home/');
+});
+
+test.describe('Chat page', () => {
+  test('it checks the page is displayed properly', async ({ page }) => {
+    await page.goto('/');
+
+    const newChatButton = page.getByRole('button', { name: 'New chat' });
+    await expect(newChatButton).toBeVisible();
+
+    const chatInput = page.getByRole('textbox', {
+      name: 'Enter your message or a',
+    });
+    await expect(chatInput).toBeVisible();
+
+    const attachmentButton = page.getByRole('button', {
+      name: 'Add attach file',
+    });
+    await expect(attachmentButton).toBeVisible();
+
+    const websearchButton = page.getByRole('button', {
+      name: 'Research on the web',
+    });
+    await expect(websearchButton).toBeVisible();
+
+    const sendMessageButton = page.getByRole('button', { name: 'Send' });
+    await expect(sendMessageButton).toBeVisible();
+  });
+
+  test('the user can chat with LLM (simple)', async ({ page }) => {
+    await page.goto('/');
+
+    const newChatButton = page.getByRole('button', { name: 'New chat' });
+    await expect(newChatButton).toBeVisible();
+
+    const chatInput = page.getByRole('textbox', {
+      name: 'Enter your message or a',
+    });
+    await chatInput.click();
+    await chatInput.fill('Hello, how are you?');
+
+    const sendMessageButton = page.getByRole('button', { name: 'Send' });
+    await expect(sendMessageButton).toBeEnabled();
+
+    await page.keyboard.press('Enter');
+
+    const copyButton = page.getByRole('button', { name: 'Copy' });
+    await expect(copyButton).toBeVisible();
+
+    const messageContent = page.getByTestId('assistant-message-content');
+    await expect(messageContent).toBeVisible();
+    await expect(messageContent).not.toBeEmpty(); 
+
+    // Check history
+    const chatHistoryLink = page
+      .getByRole('link', { name: 'Simple chat icon Hello, how' })
+      .first();
+    await expect(chatHistoryLink).toBeVisible();
+
+    await newChatButton.click();
+
+    await page
+      .getByRole('heading', { name: 'What is on your mind?' })
+      .isVisible();
+
+    await chatHistoryLink.click();
+    await expect(messageContent).toBeVisible();
+  });
+});

src/frontend/apps/e2e/__tests__/app-conversations/home.spec.ts

@@ -24,9 +24,7 @@ test.describe('Home page', () => {
 
     // Check the titles
     const h2 = page.locator('h2');
-    await expect(
-      h2.getByText('Your sovereign AI assistant'),
-    ).toBeVisible();
+    await expect(h2.getByText('Your sovereign AI assistant')).toBeVisible();
 
     await expect(footer).toBeVisible();
   });
@@ -74,9 +72,7 @@ test.describe('Home page', () => {
 
     // Check the titles
     const h2 = page.locator('h2');
-    await expect(
-      h2.getByText('Your sovereign AI assistant'),
-    ).toBeVisible();
+    await expect(h2.getByText('Your sovereign AI assistant')).toBeVisible();
 
     await expect(footer).toBeVisible();
   });

src/frontend/apps/e2e/package.json

@@ -1,6 +1,6 @@
 {
   "name": "app-e2e",
-  "version": "0.0.8",
+  "version": "0.0.10",
   "private": true,
   "scripts": {
     "lint": "eslint . --ext .ts",

src/frontend/package.json

@@ -1,6 +1,6 @@
 {
   "name": "conversations",
-  "version": "0.0.8",
+  "version": "0.0.10",
   "private": true,
   "workspaces": {
     "packages": [
@@ -32,8 +32,8 @@
     "@typescript-eslint/eslint-plugin": "8.33.1",
     "@typescript-eslint/parser": "8.33.1",
     "eslint": "8.57.0",
-    "react": "19.1.0",
-    "react-dom": "19.1.0",
+    "react": "19.2.1",
+    "react-dom": "19.2.1",
     "typescript": "5.8.3"
   }
 }

src/frontend/packages/eslint-config-conversations/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-config-conversations",
-  "version": "0.0.8",
+  "version": "0.0.10",
   "license": "MIT",
   "scripts": {
     "lint": "eslint --ext .js ."

src/frontend/packages/i18n/package.json

@@ -1,6 +1,6 @@
 {
   "name": "packages-i18n",
-  "version": "0.0.8",
+  "version": "0.0.10",
   "private": true,
   "scripts": {
     "extract-translation": "yarn extract-translation:conversations",

src/frontend/yarn.lock

@@ -1971,10 +1971,10 @@
     "@emnapi/runtime" "^1.4.3"
     "@tybys/wasm-util" "^0.9.0"
 
-"@next/env@15.3.3":
-  version "15.3.3"
-  resolved "https://registry.npmjs.org/@next/env/-/env-15.3.3.tgz"
-  integrity sha512-OdiMrzCl2Xi0VTjiQQUK0Xh7bJHnOuET2s+3V+Y40WJBAXrJeGA3f+I8MZJ/YQ3mVGi5XGR1L66oFlgqXhQ4Vw==
+"@next/env@15.3.8":
+  version "15.3.8"
+  resolved "https://registry.yarnpkg.com/@next/env/-/env-15.3.8.tgz#02326c38d315d72f2ab8b2bcc9a5c81ec5482873"
+  integrity sha512-SAfHg0g91MQVMPioeFeDjE+8UPF3j3BvHjs8ZKJAUz1BG7eMPvfCKOAgNWJ6s1MLNeP6O2InKQRTNblxPWuq+Q==
 
 "@next/eslint-plugin-next@15.3.3":
   version "15.3.3"
@@ -1983,45 +1983,45 @@
   dependencies:
     fast-glob "3.3.1"
 
-"@next/swc-darwin-arm64@15.3.3":
-  version "15.3.3"
-  resolved "https://registry.npmjs.org/@next/swc-darwin-arm64/-/swc-darwin-arm64-15.3.3.tgz"
-  integrity sha512-WRJERLuH+O3oYB4yZNVahSVFmtxRNjNF1I1c34tYMoJb0Pve+7/RaLAJJizyYiFhjYNGHRAE1Ri2Fd23zgDqhg==
+"@next/swc-darwin-arm64@15.3.5":
+  version "15.3.5"
+  resolved "https://registry.yarnpkg.com/@next/swc-darwin-arm64/-/swc-darwin-arm64-15.3.5.tgz#75606cb72e1659a23f15195dba760dc01b186c5d"
+  integrity sha512-lM/8tilIsqBq+2nq9kbTW19vfwFve0NR7MxfkuSUbRSgXlMQoJYg+31+++XwKVSXk4uT23G2eF/7BRIKdn8t8w==
 
-"@next/swc-darwin-x64@15.3.3":
-  version "15.3.3"
-  resolved "https://registry.yarnpkg.com/@next/swc-darwin-x64/-/swc-darwin-x64-15.3.3.tgz#71588bad245180ffd1af1e1f894477287e739eb0"
-  integrity sha512-XHdzH/yBc55lu78k/XwtuFR/ZXUTcflpRXcsu0nKmF45U96jt1tsOZhVrn5YH+paw66zOANpOnFQ9i6/j+UYvw==
+"@next/swc-darwin-x64@15.3.5":
+  version "15.3.5"
+  resolved "https://registry.yarnpkg.com/@next/swc-darwin-x64/-/swc-darwin-x64-15.3.5.tgz#78ffad7ef26685e5b8150891b467a4ecef94e179"
+  integrity sha512-WhwegPQJ5IfoUNZUVsI9TRAlKpjGVK0tpJTL6KeiC4cux9774NYE9Wu/iCfIkL/5J8rPAkqZpG7n+EfiAfidXA==
 
-"@next/swc-linux-arm64-gnu@15.3.3":
-  version "15.3.3"
-  resolved "https://registry.yarnpkg.com/@next/swc-linux-arm64-gnu/-/swc-linux-arm64-gnu-15.3.3.tgz#66a15f749c14f04a89f8c7e21c7a8d343fc34e6e"
-  integrity sha512-VZ3sYL2LXB8znNGcjhocikEkag/8xiLgnvQts41tq6i+wql63SMS1Q6N8RVXHw5pEUjiof+II3HkDd7GFcgkzw==
+"@next/swc-linux-arm64-gnu@15.3.5":
+  version "15.3.5"
+  resolved "https://registry.yarnpkg.com/@next/swc-linux-arm64-gnu/-/swc-linux-arm64-gnu-15.3.5.tgz#d9a405ceec729d62033dbdc48f8c331c544f09fd"
+  integrity sha512-LVD6uMOZ7XePg3KWYdGuzuvVboxujGjbcuP2jsPAN3MnLdLoZUXKRc6ixxfs03RH7qBdEHCZjyLP/jBdCJVRJQ==
 
-"@next/swc-linux-arm64-musl@15.3.3":
-  version "15.3.3"
-  resolved "https://registry.yarnpkg.com/@next/swc-linux-arm64-musl/-/swc-linux-arm64-musl-15.3.3.tgz#14bd66213f7f33d6909574750bcb05037221a2ac"
-  integrity sha512-h6Y1fLU4RWAp1HPNJWDYBQ+e3G7sLckyBXhmH9ajn8l/RSMnhbuPBV/fXmy3muMcVwoJdHL+UtzRzs0nXOf9SA==
+"@next/swc-linux-arm64-musl@15.3.5":
+  version "15.3.5"
+  resolved "https://registry.yarnpkg.com/@next/swc-linux-arm64-musl/-/swc-linux-arm64-musl-15.3.5.tgz#65f19ad3ecd2881381ec2a149afba261ba180dde"
+  integrity sha512-k8aVScYZ++BnS2P69ClK7v4nOu702jcF9AIHKu6llhHEtBSmM2zkPGl9yoqbSU/657IIIb0QHpdxEr0iW9z53A==
 
-"@next/swc-linux-x64-gnu@15.3.3":
-  version "15.3.3"
-  resolved "https://registry.yarnpkg.com/@next/swc-linux-x64-gnu/-/swc-linux-x64-gnu-15.3.3.tgz#4a19434545e5e752d9a3ed71f9b34982725f6293"
-  integrity sha512-jJ8HRiF3N8Zw6hGlytCj5BiHyG/K+fnTKVDEKvUCyiQ/0r5tgwO7OgaRiOjjRoIx2vwLR+Rz8hQoPrnmFbJdfw==
+"@next/swc-linux-x64-gnu@15.3.5":
+  version "15.3.5"
+  resolved "https://registry.yarnpkg.com/@next/swc-linux-x64-gnu/-/swc-linux-x64-gnu-15.3.5.tgz#cd7f7e002212360b99f7e791a2d2fedb352f2374"
+  integrity sha512-2xYU0DI9DGN/bAHzVwADid22ba5d/xrbrQlr2U+/Q5WkFUzeL0TDR963BdrtLS/4bMmKZGptLeg6282H/S2i8A==
 
-"@next/swc-linux-x64-musl@15.3.3":
-  version "15.3.3"
-  resolved "https://registry.yarnpkg.com/@next/swc-linux-x64-musl/-/swc-linux-x64-musl-15.3.3.tgz#41ab140dd0a04ab7291adbec5836c1ce251a588c"
-  integrity sha512-HrUcTr4N+RgiiGn3jjeT6Oo208UT/7BuTr7K0mdKRBtTbT4v9zJqCDKO97DUqqoBK1qyzP1RwvrWTvU6EPh/Cw==
+"@next/swc-linux-x64-musl@15.3.5":
+  version "15.3.5"
+  resolved "https://registry.yarnpkg.com/@next/swc-linux-x64-musl/-/swc-linux-x64-musl-15.3.5.tgz#302c9e4ace935c963d45fce9584754a19295c452"
+  integrity sha512-TRYIqAGf1KCbuAB0gjhdn5Ytd8fV+wJSM2Nh2is/xEqR8PZHxfQuaiNhoF50XfY90sNpaRMaGhF6E+qjV1b9Tg==
 
-"@next/swc-win32-arm64-msvc@15.3.3":
-  version "15.3.3"
-  resolved "https://registry.yarnpkg.com/@next/swc-win32-arm64-msvc/-/swc-win32-arm64-msvc-15.3.3.tgz#fcd1d7e0007b7b73d1acdbf0ad6d91f7aa2deb15"
-  integrity sha512-SxorONgi6K7ZUysMtRF3mIeHC5aA3IQLmKFQzU0OuhuUYwpOBc1ypaLJLP5Bf3M9k53KUUUj4vTPwzGvl/NwlQ==
+"@next/swc-win32-arm64-msvc@15.3.5":
+  version "15.3.5"
+  resolved "https://registry.yarnpkg.com/@next/swc-win32-arm64-msvc/-/swc-win32-arm64-msvc-15.3.5.tgz#5bbe1434afa2360634d45fc7860a038d11e4e296"
+  integrity sha512-h04/7iMEUSMY6fDGCvdanKqlO1qYvzNxntZlCzfE8i5P0uqzVQWQquU1TIhlz0VqGQGXLrFDuTJVONpqGqjGKQ==
 
-"@next/swc-win32-x64-msvc@15.3.3":
-  version "15.3.3"
-  resolved "https://registry.yarnpkg.com/@next/swc-win32-x64-msvc/-/swc-win32-x64-msvc-15.3.3.tgz#c0e33e069d7922dd0546cac77a0247ad81d4a1aa"
-  integrity sha512-4QZG6F8enl9/S2+yIiOiju0iCTFd93d8VC1q9LZS4p/Xuk81W2QDjCFeoogmrWWkAD59z8ZxepBQap2dKS5ruw==
+"@next/swc-win32-x64-msvc@15.3.5":
+  version "15.3.5"
+  resolved "https://registry.yarnpkg.com/@next/swc-win32-x64-msvc/-/swc-win32-x64-msvc-15.3.5.tgz#9629b2eac3159c70f3449cecc2a29bfd4bcb2d5a"
+  integrity sha512-5fhH6fccXxnX2KhllnGhkYMndhOiLOLEiVGYjP2nizqeGWkN10sA9taATlXwake2E2XMvYZjjz0Uj7T0y+z1yw==
 
 "@nodelib/fs.scandir@2.1.5":
   version "2.1.5"
@@ -6451,14 +6451,6 @@ babel-preset-jest@^29.6.3:
     babel-plugin-jest-hoist "^29.6.3"
     babel-preset-current-node-syntax "^1.0.0"
 
-babel-runtime@^6.26.0:
-  version "6.26.0"
-  resolved "https://registry.yarnpkg.com/babel-runtime/-/babel-runtime-6.26.0.tgz#965c7058668e82b55d7bfe04ff2337bc8b5647fe"
-  integrity sha512-ITKNuq2wKlW1fJg9sSW52eepoYgZBggvOAHC0u/CYu/qxQ9EVzThCgR69BnSXLHjy2f7SY5zaQ4yt7H9ZVxY2g==
-  dependencies:
-    core-js "^2.4.0"
-    regenerator-runtime "^0.11.0"
-
 bail@^2.0.0:
   version "2.0.2"
   resolved "https://registry.npmjs.org/bail/-/bail-2.0.2.tgz"
@@ -7004,11 +6996,6 @@ core-js-compat@^3.40.0:
   dependencies:
     browserslist "^4.24.4"
 
-core-js@^2.4.0:
-  version "2.6.12"
-  resolved "https://registry.yarnpkg.com/core-js/-/core-js-2.6.12.tgz#d9333dfa7b065e347cc5682219d6f690859cc2ec"
-  integrity sha512-Kb2wC0fvsWfQrgk8HU5lW6U/Lcs8+9aaYcy4ZFc6DDlo4nZ7n70dEgE5rtR0oG6ufKDUnrwfWL1mXR5ljDatrQ==
-
 core-js@^3.0.0, core-js@^3.38.1:
   version "3.42.0"
   resolved "https://registry.npmjs.org/core-js/-/core-js-3.42.0.tgz"
@@ -10097,7 +10084,14 @@ loose-envify@^1.0.0, loose-envify@^1.4.0:
   dependencies:
     js-tokens "^3.0.0 || ^4.0.0"
 
-lottie-web@^5.12.2:
+lottie-react@^2.4.1:
+  version "2.4.1"
+  resolved "https://registry.yarnpkg.com/lottie-react/-/lottie-react-2.4.1.tgz#4bd3f2a8a5e48edbd43c05ca5080fdd50f049d31"
+  integrity sha512-LQrH7jlkigIIv++wIyrOYFLHSKQpEY4zehPicL9bQsrt1rnoKRYCYgpCUe5maqylNtacy58/sQDZTkwMcTRxZw==
+  dependencies:
+    lottie-web "^5.10.2"
+
+lottie-web@^5.10.2:
   version "5.13.0"
   resolved "https://registry.yarnpkg.com/lottie-web/-/lottie-web-5.13.0.tgz#441d3df217cc8ba302338c3f168e1a3af0f221d3"
   integrity sha512-+gfBXl6sxXMPe8tKQm7qzLnUy5DUPJPKIyRHwtpCpyUEYjHYRJC/5gjUvdkuO2c3JllrPtHXH5UJJK8LRYl5yQ==
@@ -10844,12 +10838,12 @@ neo-async@^2.6.2:
   resolved "https://registry.npmjs.org/neo-async/-/neo-async-2.6.2.tgz"
   integrity sha512-Yd3UES5mWCSqR+qNT93S3UoYUkqAZ9lLg8a7g9rimsWmYGK8cVToA4/sF3RrshdyV3sAGMXVUmpMYOw+dLpOuw==
 
-next@15.3.3:
-  version "15.3.3"
-  resolved "https://registry.npmjs.org/next/-/next-15.3.3.tgz"
-  integrity sha512-JqNj29hHNmCLtNvd090SyRbXJiivQ+58XjCcrC50Crb5g5u2zi7Y2YivbsEfzk6AtVI80akdOQbaMZwWB1Hthw==
+next@15.3.8:
+  version "15.3.8"
+  resolved "https://registry.yarnpkg.com/next/-/next-15.3.8.tgz#c7df2fa890c66fa3042e85437e3c1e8e6bd38b26"
+  integrity sha512-L+4c5Hlr84fuaNADZbB9+ceRX9/CzwxJ+obXIGHupboB/Q1OLbSUapFs4bO8hnS/E6zV/JDX7sG1QpKVR2bguA==
   dependencies:
-    "@next/env" "15.3.3"
+    "@next/env" "15.3.8"
     "@swc/counter" "0.1.3"
     "@swc/helpers" "0.5.15"
     busboy "1.6.0"
@@ -10857,14 +10851,14 @@ next@15.3.3:
     postcss "8.4.31"
     styled-jsx "5.1.6"
   optionalDependencies:
-    "@next/swc-darwin-arm64" "15.3.3"
-    "@next/swc-darwin-x64" "15.3.3"
-    "@next/swc-linux-arm64-gnu" "15.3.3"
-    "@next/swc-linux-arm64-musl" "15.3.3"
-    "@next/swc-linux-x64-gnu" "15.3.3"
-    "@next/swc-linux-x64-musl" "15.3.3"
-    "@next/swc-win32-arm64-msvc" "15.3.3"
-    "@next/swc-win32-x64-msvc" "15.3.3"
+    "@next/swc-darwin-arm64" "15.3.5"
+    "@next/swc-darwin-x64" "15.3.5"
+    "@next/swc-linux-arm64-gnu" "15.3.5"
+    "@next/swc-linux-arm64-musl" "15.3.5"
+    "@next/swc-linux-x64-gnu" "15.3.5"
+    "@next/swc-linux-x64-musl" "15.3.5"
+    "@next/swc-win32-arm64-msvc" "15.3.5"
+    "@next/swc-win32-x64-msvc" "15.3.5"
     sharp "^0.34.1"
 
 no-case@^3.0.4:
@@ -11428,7 +11422,7 @@ prompts@^2.0.1:
     kleur "^3.0.3"
     sisteransi "^1.0.5"
 
-prop-types@^15.6.0, prop-types@^15.6.1, prop-types@^15.6.2, prop-types@^15.7.2, prop-types@^15.8.1:
+prop-types@^15.6.0, prop-types@^15.6.2, prop-types@^15.7.2, prop-types@^15.8.1:
   version "15.8.1"
   resolved "https://registry.npmjs.org/prop-types/-/prop-types-15.8.1.tgz"
   integrity sha512-oj87CgZICdulUohogVAR7AjlC0327U4el4L6eAvOqCeudMDVU0NThNaV+b9Df4dXgSP1gXMTnPdhfe/2qDH5cg==
@@ -11785,12 +11779,12 @@ react-dnd@^14.0.3:
     fast-deep-equal "^3.1.3"
     hoist-non-react-statics "^3.3.2"
 
-react-dom@18.3.1, react-dom@19.0.0, react-dom@19.1.0:
-  version "19.1.0"
-  resolved "https://registry.yarnpkg.com/react-dom/-/react-dom-19.1.0.tgz#133558deca37fa1d682708df8904b25186793623"
-  integrity sha512-Xs1hdnE+DyKgeHJeJznQmYMIBG3TKIHJJT95Q58nHLSrElKlGQqDTR2HQ9fx5CN/Gk6Vh/kupBTDLU11/nDk/g==
+react-dom@19.0.0, react-dom@19.2.1:
+  version "19.2.1"
+  resolved "https://registry.yarnpkg.com/react-dom/-/react-dom-19.2.1.tgz#ce3527560bda4f997e47d10dab754825b3061f59"
+  integrity sha512-ibrK8llX2a4eOskq1mXKu/TGZj9qzomO+sNfO98M6d9zIPOEhlBkMkBUBLd1vgS0gQsLDBzA+8jJBVXDnfHmJg==
   dependencies:
-    scheduler "^0.26.0"
+    scheduler "^0.27.0"
 
 react-i18next@15.5.2:
   version "15.5.2"
@@ -11825,15 +11819,6 @@ react-lifecycles-compat@^3.0.0:
   resolved "https://registry.npmjs.org/react-lifecycles-compat/-/react-lifecycles-compat-3.0.4.tgz"
   integrity sha512-fBASbA6LnOU9dOU2eW7aQ8xmYBSXUIWr+UmF9b1efZBazGNO+rcXT/icdKnYm2pTwcRylVUYwW7H1PHfLekVzA==
 
-react-lottie@^1.2.10:
-  version "1.2.10"
-  resolved "https://registry.yarnpkg.com/react-lottie/-/react-lottie-1.2.10.tgz#399f78a448a7833b2380d74fc489ecf15f8d18c7"
-  integrity sha512-x0eWX3Z6zSx1XM5QSjnLupc6D22LlMCB0PH06O/N/epR2hsLaj1Vxd9RtMnbbEHjJ/qlsgHJ6bpN3vnZI92hjw==
-  dependencies:
-    babel-runtime "^6.26.0"
-    lottie-web "^5.12.2"
-    prop-types "^15.6.1"
-
 react-markdown@10.1.0:
   version "10.1.0"
   resolved "https://registry.npmjs.org/react-markdown/-/react-markdown-10.1.0.tgz"
@@ -12021,10 +12006,10 @@ react-window@^1.8.11:
     "@babel/runtime" "^7.0.0"
     memoize-one ">=3.1.1 <6"
 
-react@*, react@19.0.0, react@19.1.0:
-  version "19.1.0"
-  resolved "https://registry.yarnpkg.com/react/-/react-19.1.0.tgz#926864b6c48da7627f004795d6cce50e90793b75"
-  integrity sha512-FS+XFBNvn3GTAWq26joslQgWNoFu08F4kl0J4CgdNKADkdSGXQyTCnKteIAJy96Br6YbpEU1LSzV5dYtjMkMDg==
+react@19.0.0, react@19.2.1:
+  version "19.2.1"
+  resolved "https://registry.yarnpkg.com/react/-/react-19.2.1.tgz#8600fa205e58e2e807f6ef431c9f6492591a2700"
+  integrity sha512-DGrYcCWK7tvYMnWh79yrPHt+vdx9tY+1gPZa7nJQtO/p8bLTDaHp4dzwEhQB7pZ4Xe3ok4XKuEPrVuc+wlpkmw==
 
 readable-stream@^3.4.0:
   version "3.6.2"
@@ -12101,11 +12086,6 @@ regenerate@^1.4.2:
   resolved "https://registry.npmjs.org/regenerate/-/regenerate-1.4.2.tgz"
   integrity sha512-zrceR/XhGYU/d/opr2EKO7aRHUeiBI8qjtfHqADTwZd6Szfy16la6kqD0MIUs5z5hx6AaKa+PixpPrR289+I0A==
 
-regenerator-runtime@^0.11.0:
-  version "0.11.1"
-  resolved "https://registry.yarnpkg.com/regenerator-runtime/-/regenerator-runtime-0.11.1.tgz#be05ad7f9bf7d22e056f9726cee5017fbf19e2e9"
-  integrity sha512-MguG95oij0fC3QV3URf4V2SDYGJhJnJGqvIIgdECeODCT98wSWDAJ94SSuVpYQUoTcGUIL6L4yNB7j1DFFHSBg==
-
 regex-recursion@^6.0.2:
   version "6.0.2"
   resolved "https://registry.yarnpkg.com/regex-recursion/-/regex-recursion-6.0.2.tgz#a0b1977a74c87f073377b938dbedfab2ea582b33"
@@ -12464,10 +12444,10 @@ scheduler@0.25.0-rc-603e6108-20241029:
   resolved "https://registry.npmjs.org/scheduler/-/scheduler-0.25.0-rc-603e6108-20241029.tgz"
   integrity sha512-pFwF6H1XrSdYYNLfOcGlM28/j8CGLu8IvdrxqhjWULe2bPcKiKW4CV+OWqR/9fT52mywx65l7ysNkjLKBda7eA==
 
-scheduler@^0.26.0:
-  version "0.26.0"
-  resolved "https://registry.yarnpkg.com/scheduler/-/scheduler-0.26.0.tgz#4ce8a8c2a2095f13ea11bf9a445be50c555d6337"
-  integrity sha512-NlHwttCI/l5gCPR3D1nNXtWABUmBwvZpEQiD4IXSbIDq8BzLIK/7Ir5gTFSGZDUu37K5cMNp0hFtzO38sC7gWA==
+scheduler@^0.27.0:
+  version "0.27.0"
+  resolved "https://registry.yarnpkg.com/scheduler/-/scheduler-0.27.0.tgz#0c4ef82d67d1e5c1e359e8fc76d3a87f045fe5bd"
+  integrity sha512-eNv+WrVbKu1f3vbYJT/xtiF5syA5HPIMtf9IgY/nKg0sWqzAUEvqY/xm7OcZc/qafLx/iO9FgOmeSAp4v5ti/Q==
 
 schema-utils@^4.3.0, schema-utils@^4.3.2:
   version "4.3.2"

src/mail/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mail_mjml",
-  "version": "0.0.8",
+  "version": "0.0.10",
   "description": "An util to generate html and text django's templates from mjml templates",
   "type": "module",
   "dependencies": {