Spaces:

Docfile
/

Mariam-cards

Sleeping

App Files Files Community

Docfile commited on Mar 26

Commit

d8ece29

verified ·

1 Parent(s): 04942cf

Create maj.html

Browse files

Files changed (1) hide show

templates/maj.html +587 -0

templates/maj.html ADDED Viewed

	@@ -0,0 +1,587 @@

+<!DOCTYPE html>
+<html lang="fr">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Mariam | Solution Mathématique (Corrigé)</title>
+  <!-- Tailwind CSS via CDN -->
+  <link href="https://cdn.jsdelivr.net/npm/[email protected]/dist/tailwind.min.css" rel="stylesheet">
+  <!-- Configuration MathJax Optimisée -->
+  <script>
+    window.MathJax = {
+      tex: {
+        inlineMath: [['$', '$']],          // Délimiteurs maths en ligne
+        displayMath: [['$$', '$$']],      // Délimiteurs maths en bloc
+        processEscapes: true,            // Permet \$ pour un dollar littéral
+        // Packages TeX courants pour maths/physique/chimie complexes
+        // 'autoload': Charge dynamiquement les commandes inconnues (flexible)
+        // 'ams': Environnements AMSMath (align, gather, matrix...)
+        // 'mhchem': Notation chimique (\ce{})
+        // 'physics': Notations physiques (\vec, \abs, \dv, \qty...)
+        // 'boldsymbol': Pour \boldsymbol{}
+        packages: {'[+]': ['autoload', 'ams', 'mhchem', 'physics', 'boldsymbol']}
+      },
+      chtml: {
+        // Options pour le rendu CommonHTML (généralement le plus rapide)
+        // fontURL: 'https://cdn.jsdelivr.net/npm/mathjax@3/es5/output/chtml/fonts/woff-v2' // Optionnel: URL des polices
+      },
+      options: {
+        enableMenu: false,               // Désactive menu contextuel MathJax
+        messageStyle: 'none',            // Supprime messages statut MathJax
+        skipHtmlTags: ['script', 'noscript', 'style', 'textarea', 'pre', 'code'], // Tags à ignorer
+        ignoreHtmlClass: 'tex2jax_ignore', // Classe CSS pour ignorer éléments
+        processHtmlClass: 'tex2jax_process' // Classe CSS pour forcer traitement
+      },
+      startup: {
+        // Callback quand MathJax est prêt
+        pageReady: () => {
+          console.log('MathJax est complètement chargé et prêt.');
+          window.mathJaxReady = true; // Drapeau global
+        }
+      }
+    };
+  </script>
+  <!-- Chargement MathJax (tex-mml-chtml pour compatibilité maximale) -->
+  <script src="https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js" id="MathJax-script" async></script>
+  <!-- Chargement Marked.js (pour rendu Markdown) -->
+  <script src="https://cdn.jsdelivr.net/npm/marked/lib/marked.umd.min.js"></script>
+  <style>
+    /* Importation Google Font */
+    @import url('https://fonts.googleapis.com/css2?family=Space+Grotesk:wght@400;500;700&display=swap');
+    body {
+      font-family: 'Space Grotesk', sans-serif;
+      -webkit-font-smoothing: antialiased;
+      -moz-osx-font-smoothing: grayscale;
+    }
+    /* Zone d'upload */
+    .uploadArea {
+      background: #f9fafb; /* bg-gray-50 */
+      border: 2px dashed #d1d5db; /* border-gray-300 */
+      transition: border-color 0.2s ease-in-out, background-color 0.2s ease-in-out;
+      cursor: pointer;
+    }
+    .uploadArea:hover, .uploadArea.dragover { /* Ajout classe pour dragover */
+      border-color: #3b82f6; /* border-blue-500 */
+      background-color: #eff6ff; /* bg-blue-50 */
+    }
+    /* Bouton principal */
+    .blue-button {
+      background-color: #3b82f6; /* bg-blue-500 */
+      transition: background-color 0.2s ease-in-out, box-shadow 0.2s ease-in-out;
+    }
+    .blue-button:hover {
+      background-color: #2563eb; /* bg-blue-600 */
+      box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -1px rgba(0, 0, 0, 0.06); /* shadow-md */
+    }
+    .blue-button:disabled {
+      background-color: #9ca3af; /* bg-gray-400 */
+      cursor: not-allowed;
+      box-shadow: none;
+    }
+    /* Indicateur chargement */
+    .loader {
+      width: 40px; height: 40px; border: 4px solid #3b82f6; border-bottom-color: transparent;
+      border-radius: 50%; display: inline-block; box-sizing: border-box;
+      animation: rotation 1s linear infinite;
+    }
+    @keyframes rotation { 0% { transform: rotate(0deg); } 100% { transform: rotate(360deg); } }
+    /* Boîte de réflexion (accordéon) */
+    .thought-box {
+      transition: max-height 0.3s ease-out, border-top-width 0.3s ease-out;
+      max-height: 0; overflow: hidden; background-color: #f9fafb; /* bg-gray-50 */
+      border-radius: 0 0 0.5rem 0.5rem; border-top: 0px solid #e5e7eb; /* border-gray-200 */
+    }
+    .thought-box.open {
+      max-height: 600px; /* Ajustable */ border-top-width: 1px;
+    }
+    /* Zones de contenu (réflexion, réponse) */
+    #thoughtsContent, #answerContent {
+      max-height: 600px; /* Ajustable */ overflow-y: auto; scroll-behavior: smooth;
+      white-space: pre-wrap; word-wrap: break-word;
+      background-color: #ffffff; padding: 1rem; border-radius: 0.375rem; /* rounded-md */
+      border: 1px solid #e5e7eb; /* border-gray-200 */
+      line-height: 1.6; /* Améliore lisibilité */
+    }
+    #thoughtsContent { background-color: #f9fafb; /* bg-gray-50 */ }
+    /* Image prévisualisation */
+    .preview-image {
+      max-width: 100%; height: auto; max-height: 300px; object-fit: contain;
+      margin-top: 0.5rem; border: 1px solid #e5e7eb; border-radius: 0.375rem;
+    }
+    /* Timestamp */
+    .timestamp { color: #6b7280; font-size: 0.8em; margin-left: 10px; font-weight: 500; }
+    /* Tableaux */
+    table { border-collapse: collapse; width: 100%; margin-bottom: 1rem; border: 1px solid #d1d5db; }
+    th, td { border: 1px solid #d1d5db; padding: 0.75rem; text-align: left; }
+    th { background-color: #f3f4f6; font-weight: 600; }
+    .table-responsive { overflow-x: auto; }
+    /* Avertissement Performance */
+    .performance-warning {
+        color: #991b1b; /* text-red-800 */ font-weight: 500; font-size: 0.9em;
+        margin-top: 1rem; margin-bottom: 1.5rem; padding: 0.75rem;
+        background-color: #fee2e2; /* bg-red-100 */ border: 1px solid #fca5a5; /* border-red-300 */
+        border-radius: 0.375rem; text-align: center;
+    }
+  </style>
+</head>
+<body class="p-4 bg-gray-100 min-h-screen">
+  <!-- Conteneur principal centré -->
+  <div class="max-w-4xl mx-auto bg-white p-5 md:p-8 rounded-lg shadow-lg">
+    <header class="text-center mb-6 md:mb-8">
+      <h1 class="text-3xl md:text-4xl font-bold text-blue-600">Mariam - M-0</h1>
+      <p class="text-gray-600 mt-2">Solution Mathématique/Physique/Chimie Intelligente</p>
+      <p class="performance-warning">
+        Vous utilisez les modèles/performances standards. Passez à Premium pour une résolution plus rapide et précise !
+      </p>
+    </header>
+    <main>
+      <form id="problemForm" class="space-y-6" novalidate>
+        <!-- Zone d'Upload -->
+        <div id="uploadArea" class="uploadArea p-6 md:p-8 text-center relative rounded-lg" aria-label="Zone de dépôt d'image du problème">
+          {/* Input fichier caché, mais lié par le clic sur la div */}
+          <input type="file" id="imageInput" accept="image/*" class="absolute inset-0 w-full h-full opacity-0 cursor-pointer" aria-label="Choisir une image" aria-describedby="upload-instructions">
+          <div class="flex flex-col items-center justify-center space-y-3 pointer-events-none" id="upload-instructions"> {/* pointer-events-none pour laisser passer le clic vers l'input */}
+            {/* Icone SVG */}
+            <svg class="w-12 h-12 text-blue-500" fill="none" stroke="currentColor" viewBox="0 0 24 24" aria-hidden="true"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M4 16l4.586-4.586a2 2 0 012.828 0L16 16m-2-2l1.586-1.586a2 2 0 012.828 0L20 14m-6-6h.01M6 20h12a2 2 0 002-2V6a2 2 0 00-2-2H6a2 2 0 00-2 2v12a2 2 0 002 2z" /></svg>
+            <p class="text-gray-700 font-medium">Déposez l'image du problème ici</p>
+            <p class="text-gray-500 text-sm">ou cliquez pour sélectionner</p>
+            <p class="text-xs text-gray-400 mt-1">(Formats: JPG, PNG, WEBP, etc.)</p>
+          </div>
+        </div>
+        <!-- Prévisualisation Image -->
+        <div id="imagePreview" class="hidden text-center border border-gray-200 p-3 rounded-lg">
+          <p class="text-sm font-medium text-gray-700 mb-2">Image sélectionnée :</p>
+          <img id="previewImage" class="preview-image mx-auto" alt="Prévisualisation de l'image sélectionnée">
+          <button type="button" id="removeImageBtn" class="mt-3 text-sm text-red-600 hover:text-red-800 font-medium" aria-label="Retirer l'image sélectionnée">
+            Retirer l'image
+          </button>
+        </div>
+        <!-- Bouton Soumettre -->
+        <button type="submit" id="submitButton" class="blue-button w-full py-3 text-white font-medium rounded-lg text-lg">
+          Résoudre le problème
+        </button>
+      </form>
+      <!-- Indicateur de Chargement -->
+      <div id="loader" class="hidden mt-8 text-center" aria-busy="true" aria-label="Analyse en cours">
+        <span class="loader"></span>
+        <p class="mt-3 text-gray-600 font-medium">Analyse en cours...</p>
+      </div>
+      <!-- Section Solution -->
+      <section id="solution" class="hidden mt-10 space-y-8">
+        <!-- Accordéon Réflexion -->
+        <div class="border rounded-lg shadow-sm overflow-hidden">
+          <button id="thoughtsToggle" type="button" class="w-full flex justify-between items-center p-3 bg-gray-100 hover:bg-gray-200 transition-colors duration-150 ease-in-out focus:outline-none focus:ring-2 focus:ring-blue-300" aria-expanded="true" aria-controls="thoughtsBox">
+            <span class="font-medium text-gray-800 text-lg">Processus de Réflexion</span>
+            <div class="flex items-center">
+                <span id="timestamp" class="timestamp"></span>
+                {/* Icône Chevron */}
+                <svg id="toggleIcon" class="w-5 h-5 text-gray-600 ml-2 transform transition-transform duration-200 rotate-180" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M19 9l-7 7-7-7"></path></svg>
+            </div>
+          </button>
+          <div id="thoughtsBox" class="thought-box open" role="region" aria-labelledby="thoughtsToggle">
+            {/* aria-live="polite" annonce les MAJ aux lecteurs d'écran */}
+            <div id="thoughtsContent" class="p-4 text-gray-700 text-sm" aria-live="polite"></div>
+          </div>
+        </div>
+        <!-- Section Solution Détaillée -->
+        <div class="border-t pt-6">
+          <h3 class="text-xl font-bold text-gray-800 mb-4">Solution Détaillée</h3>
+          <div id="answerContent" class="text-gray-800 table-responsive" aria-live="polite">
+             {/* Le contenu généré par Markdown et rendu par MathJax ira ici */}
+          </div>
+        </div>
+      </section>
+    </main>
+    <footer class="text-center mt-12 pt-6 border-t border-gray-200">
+      <p class="text-sm text-gray-500">© 2024 Mariam AI. Tous droits réservés.</p>
+    </footer>
+  </div>
+  <script>
+    document.addEventListener('DOMContentLoaded', () => {
+      // --- DOM Element References ---
+      const form = document.getElementById('problemForm');
+      const imageInput = document.getElementById('imageInput');
+      const loader = document.getElementById('loader');
+      const solutionSection = document.getElementById('solution');
+      const thoughtsContent = document.getElementById('thoughtsContent');
+      const answerContent = document.getElementById('answerContent');
+      const thoughtsToggle = document.getElementById('thoughtsToggle');
+      const thoughtsBox = document.getElementById('thoughtsBox');
+      const toggleIcon = document.getElementById('toggleIcon');
+      const imagePreview = document.getElementById('imagePreview');
+      const previewImage = document.getElementById('previewImage');
+      const removeImageBtn = document.getElementById('removeImageBtn');
+      const timestamp = document.getElementById('timestamp');
+      const uploadArea = document.getElementById('uploadArea');
+      const submitButton = document.getElementById('submitButton');
+      // --- State Variables ---
+      let startTime = null;
+      let timerInterval = null;
+      let thoughtsBuffer = '';
+      let answerBuffer = '';
+      let currentMode = null; // 'thinking' or 'answering'
+      let updateTimeout = null; // For debouncing/throttling UI updates
+      let mathJaxProcessing = false; // Flag to prevent concurrent MathJax calls
+      // --- Marked.js Configuration ---
+      marked.setOptions({
+        gfm: true,          // Enable GitHub Flavored Markdown (tables, etc.)
+        breaks: true,       // Convert single line breaks to <br>
+        mangle: false,      // Disable email address obfuscation
+        headerIds: false,   // Disable automatic header ID generation
+      });
+      // --- Utility Functions ---
+      // Updates the timestamp display
+      const updateTimestamp = () => {
+        if (startTime) {
+          const seconds = Math.floor((Date.now() - startTime) / 1000);
+          timestamp.textContent = `${seconds}s`;
+        } else {
+          timestamp.textContent = '';
+        }
+      };
+      // Starts the timer
+      const startTimer = () => {
+        startTime = Date.now();
+        timestamp.textContent = '0s'; // Initial display
+        updateTimestamp(); // Update immediately
+        timerInterval = setInterval(updateTimestamp, 1000);
+      };
+      // Stops the timer
+      const stopTimer = () => {
+        clearInterval(timerInterval);
+        timerInterval = null;
+        if (startTime) updateTimestamp(); // Final update
+        // startTime = null; // Keep startTime to show final duration
+      };
+      // Resets the UI state before a new request or after an error
+      const resetUI = (clearImage = false) => {
+          loader.classList.add('hidden');
+          loader.removeAttribute('aria-busy');
+          solutionSection.classList.add('hidden');
+          thoughtsContent.innerHTML = '';
+          answerContent.innerHTML = '';
+          thoughtsBuffer = '';
+          answerBuffer = '';
+          currentMode = null;
+          if (!thoughtsBox.classList.contains('open')) { // Re-open if closed
+              thoughtsBox.classList.add('open');
+              toggleIcon.classList.add('rotate-180');
+              thoughtsToggle.setAttribute('aria-expanded', 'true');
+          }
+          stopTimer(); // Ensure any previous timer is stopped
+          updateTimestamp(); // Clear or show final time based on startTime
+          startTime = null; // Reset startTime for next run
+          submitButton.disabled = false; // Re-enable submit button
+          submitButton.textContent = 'Résoudre le problème'; // Reset button text
+          if(clearImage) clearImagePreview(); // Optionally clear image
+      };
+      // Handles file selection and displays preview
+      const handleFileSelect = file => {
+        if (!file || !file.type.startsWith('image/')) {
+            alert('Veuillez sélectionner un fichier image valide (JPG, PNG, WEBP, etc.).');
+            clearImagePreview();
+            return;
+        }
+        const reader = new FileReader();
+        reader.onload = e => {
+          previewImage.src = e.target.result;
+          imagePreview.classList.remove('hidden');
+          uploadArea.classList.add('hidden'); // Hide upload zone
+        };
+        reader.onerror = () => {
+            alert('Erreur lors de la lecture du fichier image.');
+            clearImagePreview();
+        };
+        reader.readAsDataURL(file);
+      };
+      // Clears the image preview and related input
+      const clearImagePreview = () => {
+          imageInput.value = ''; // Crucial to allow re-selecting the same file
+          previewImage.src = '';
+          imagePreview.classList.add('hidden');
+          uploadArea.classList.remove('hidden'); // Show upload zone again
+      };
+      // Typesets the answer content using MathJax if ready
+      const typesetAnswerIfReady = async () => {
+        if (!window.mathJaxReady) {
+          console.warn("MathJax not ready, deferring typesetting.");
+          setTimeout(typesetAnswerIfReady, 200); // Retry later
+          return;
+        }
+        if (mathJaxProcessing) {
+            console.log("MathJax is already processing, skipping this typeset call.");
+            return; // Avoid concurrent processing
+        }
+        const answerElement = document.getElementById('answerContent');
+        if (!answerElement || !answerElement.innerHTML.trim()) {
+            // console.log("No content in answerElement to typeset.");
+            return; // Nothing to typeset
+        }
+        mathJaxProcessing = true;
+        // console.log("Starting MathJax typesetting...");
+        try {
+          // Clear previous typesetting state for the element (important for dynamic content)
+          // MathJax.startup.document.clear(); // Use cautiously, might be too broad
+          // MathJax.startup.document.clearMath(answerElement); // Safer alternative if needed
+          // Typeset only the answer content
+          await MathJax.typesetPromise([answerElement]);
+          // console.log("MathJax typesetting finished.");
+          // Scroll to bottom after typesetting to show latest content
+          answerElement.scrollTop = answerElement.scrollHeight;
+        } catch (error) {
+          console.error("Error during MathJax typesetting:", error);
+          // Optionally display an error message to the user
+        } finally {
+          mathJaxProcessing = false;
+          // console.log("MathJax processing flag set to false.");
+        }
+      };
+      // Updates the display with buffered content (Markdown parsing + MathJax trigger)
+      const updateDisplay = async (forceMathJax = false) => {
+        // console.log("updateDisplay called");
+        clearTimeout(updateTimeout); // Clear pending timeout
+        updateTimeout = null; // Reset timeout ID
+        thoughtsContent.innerHTML = marked.parse(thoughtsBuffer);
+        answerContent.innerHTML = marked.parse(answerBuffer);
+        // Scroll thoughts/answer to bottom (optional, useful during streaming)
+        // thoughtsContent.scrollTop = thoughtsContent.scrollHeight;
+        // answerContent.scrollTop = answerContent.scrollHeight; // Moved after typeset
+        // Trigger MathJax typesetting for the answer section
+        // Use await only if forced (e.g., at the very end), otherwise let it run async
+        if (forceMathJax) {
+            await typesetAnswerIfReady();
+        } else {
+            typesetAnswerIfReady(); // Don't wait, let it run async
+        }
+      };
+      // Schedules a UI update (throttling)
+      const scheduleUpdate = () => {
+        // If a timeout is already pending, do nothing (throttle)
+        if (updateTimeout) return;
+        // Schedule updateDisplay after a short delay (e.g., 150ms)
+        updateTimeout = setTimeout(() => updateDisplay(false), 150);
+      };
+      // --- Event Listeners Setup ---
+      // Toggle thoughts box visibility
+      thoughtsToggle.addEventListener('click', () => {
+        const isOpen = thoughtsBox.classList.toggle('open');
+        thoughtsToggle.setAttribute('aria-expanded', isOpen);
+        toggleIcon.classList.toggle('rotate-180', isOpen);
+      });
+      // Handle file input change
+      imageInput.addEventListener('change', e => {
+          if (e.target.files && e.target.files.length > 0) {
+              handleFileSelect(e.target.files[0]);
+          } else {
+              clearImagePreview(); // Handle cancellation
+          }
+      });
+      // Remove image button
+      removeImageBtn.addEventListener('click', clearImagePreview);
+      // Drag & Drop listeners for upload area
+      ['dragenter', 'dragover', 'dragleave', 'drop'].forEach(eventName => {
+        uploadArea.addEventListener(eventName, e => {
+          e.preventDefault();
+          e.stopPropagation();
+        }, false);
+      });
+      ['dragenter', 'dragover'].forEach(eventName => {
+        uploadArea.addEventListener(eventName, () => uploadArea.classList.add('dragover'), false);
+      });
+      ['dragleave', 'drop'].forEach(eventName => {
+        uploadArea.addEventListener(eventName, () => uploadArea.classList.remove('dragover'), false);
+      });
+      uploadArea.addEventListener('drop', e => {
+        if (e.dataTransfer.files && e.dataTransfer.files.length > 0) {
+          const file = e.dataTransfer.files[0];
+          imageInput.files = e.dataTransfer.files; // Assign dropped file(s) to input
+          handleFileSelect(file);
+        }
+      }, false);
+      // Form submission handler
+      form.addEventListener('submit', async e => {
+        e.preventDefault();
+        const file = imageInput.files[0];
+        if (!file) {
+          alert('Veuillez sélectionner une image contenant le problème.');
+          return;
+        }
+        resetUI(); // Reset UI elements and state (keeps image preview by default)
+        startTimer();
+        loader.classList.remove('hidden');
+        loader.setAttribute('aria-busy', 'true');
+        submitButton.disabled = true;
+        submitButton.textContent = 'Analyse en cours...';
+        const formData = new FormData();
+        formData.append('image', file);
+        try {
+          const response = await fetch('/solved', { // Ensure '/solved' is your correct API endpoint
+            method: 'POST',
+            body: formData,
+          });
+          // --- Handle HTTP Errors ---
+          if (!response.ok) {
+            let errorMsg = `Erreur serveur ${response.status}: ${response.statusText}`;
+            try {
+              // Try to get more details from response body
+              const errorData = await response.json();
+              errorMsg += `\n\nDétails: ${JSON.stringify(errorData.error || errorData.message || errorData, null, 2)}`;
+            } catch (parseError) {
+               errorMsg += "\n(Impossible de lire les détails de l'erreur depuis la réponse)";
+            }
+            throw new Error(errorMsg);
+          }
+          // --- Process Streaming Response (SSE) ---
+          const reader = response.body?.getReader();
+          if (!reader) {
+            throw new Error("Impossible d'obtenir le lecteur de flux de la réponse.");
+          }
+          const decoder = new TextDecoder(); // Defaults to UTF-8
+          let sseBuffer = ''; // Buffer for incomplete SSE messages
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+              // Process any remaining data in the buffer if needed (unlikely for well-formed SSE)
+              if (sseBuffer.startsWith('data:')) {
+                console.warn("Processing remaining SSE buffer:", sseBuffer);
+                 try {
+                    const finalJsonData = sseBuffer.slice(5).trim();
+                    if (finalJsonData) {
+                        const finalData = JSON.parse(finalJsonData);
+                        if (finalData.content) {
+                             if (currentMode === 'thinking') thoughtsBuffer += finalData.content;
+                             else if (currentMode === 'answering') answerBuffer += finalData.content;
+                        }
+                    }
+                 } catch (finalParseError) {
+                    console.error('Error parsing final SSE buffer:', finalParseError, 'Buffer:', sseBuffer);
+                 }
+              }
+              break; // Exit loop when stream is finished
+            }
+            // Decode chunk and add to buffer
+            sseBuffer += decoder.decode(value, { stream: true });
+            // Process complete messages in the buffer (separated by '\n\n')
+            let boundaryIndex;
+            while ((boundaryIndex = sseBuffer.indexOf('\n\n')) >= 0) {
+              const message = sseBuffer.slice(0, boundaryIndex);
+              sseBuffer = sseBuffer.slice(boundaryIndex + 2); // Remove message + '\n\n'
+              if (!message.startsWith('data:')) continue; // Ignore non-data lines/comments
+              try {
+                const jsonData = message.slice(5).trim(); // Extract JSON payload
+                if (!jsonData) continue; // Ignore empty data messages
+                const data = JSON.parse(jsonData);
+                // Handle mode change
+                if (data.mode && data.mode !== currentMode) {
+                  currentMode = data.mode;
+                  // Show solution section and hide loader on first message
+                   if (loader.classList.contains('hidden') === false) {
+                      loader.classList.add('hidden');
+                      loader.removeAttribute('aria-busy');
+                      solutionSection.classList.remove('hidden');
+                   }
+                }
+                // Append content to the correct buffer
+                if (data.content) {
+                  if (currentMode === 'thinking') {
+                    thoughtsBuffer += data.content;
+                  } else if (currentMode === 'answering') {
+                    answerBuffer += data.content;
+                  }
+                  // Schedule a UI update (throttled)
+                  scheduleUpdate();
+                }
+              } catch (parseError) {
+                console.error('Error parsing SSE JSON data:', parseError, 'Message:', message);
+                // Decide how to handle: skip message, show error, etc.
+              }
+            } // End while(boundaryIndex)
+          } // End while(true) reading stream
+          // --- Final Actions After Stream ---
+          stopTimer();
+          submitButton.textContent = 'Résolu !';
+          // Force a final update and MathJax rendering
+          await updateDisplay(true); // true forces awaiting MathJax
+        } catch (error) {
+          console.error('Erreur lors de la résolution:', error);
+          alert(`Une erreur est survenue:\n${error.message}`);
+          // Reset UI, potentially clearing the image if it caused the error
+          resetUI(false); // Keep image preview in case user wants to retry
+        } finally {
+            // Ensure button is re-enabled even if something unexpected happens after success
+            // (already handled in resetUI, but as a safeguard)
+             if (!submitButton.disabled) { // If not already enabled by resetUI in error case
+                 // Might need a slight delay if called right after stopTimer/final update
+                 // setTimeout(() => { submitButton.disabled = false; }, 100);
+             }
+        }
+      }); // End form submit listener
+    }); // End DOMContentLoaded listener
+  </script>
+</body>
+</html>