iatoolkit 0.71.4__py3-none-any.whl → 1.4.2__py3-none-any.whl

iatoolkit/services/user_session_context_service.py

@@ -15,55 +15,101 @@ class UserSessionContextService:
     Esto mejora la atomicidad y la eficiencia.
     """
 
-    def _get_session_key(self, company_short_name: str, user_identifier: str) -> Optional[str]:
+    def _get_session_key(self, company_short_name: str, user_identifier: str, model: str = None) -> Optional[str]:
         """Devuelve la clave única de Redis para el Hash de sesión del usuario."""
         user_identifier = (user_identifier or "").strip()
         if not company_short_name or not user_identifier:
             return None
-        return f"session:{company_short_name}/{user_identifier}"
 
-    def clear_all_context(self, company_short_name: str, user_identifier: str):
-        """Limpia el contexto del LLM en la sesión para un usuario de forma atómica."""
-        session_key = self._get_session_key(company_short_name, user_identifier)
+        model_key = "" if not model else f"-{model}"
+        return f"session:{company_short_name}/{user_identifier}{model_key}"
+
+    def clear_all_context(self, company_short_name: str, user_identifier: str, model: str = None):
+        """Clears LLM-related context for a user (history and response IDs), preserving profile_data."""
+        session_key = self._get_session_key(company_short_name, user_identifier, model=model)
         if session_key:
-            # RedisSessionManager.remove(session_key)
             # 'profile_data' should not be deleted
-            RedisSessionManager.hdel(session_key, 'context_version')
-            RedisSessionManager.hdel(session_key, 'context_history')
-            RedisSessionManager.hdel(session_key, 'last_response_id')
+            RedisSessionManager.hdel(session_key, "context_version")
+            RedisSessionManager.hdel(session_key, "context_history")
+            RedisSessionManager.hdel(session_key, "last_response_id")
 
-    def clear_llm_history(self, company_short_name: str, user_identifier: str):
-        """Limpia solo los campos relacionados con el historial del LLM (ID y chat)."""
-        session_key = self._get_session_key(company_short_name, user_identifier)
+    def clear_llm_history(self, company_short_name: str, user_identifier: str, model: str = None):
+        """Clears only LLM history fields (last_response_id and context_history)."""
+        session_key = self._get_session_key(company_short_name, user_identifier, model=model)
         if session_key:
-            RedisSessionManager.hdel(session_key, 'last_response_id', 'context_history')
+            RedisSessionManager.hdel(session_key, "last_response_id", "context_history")
 
-    def get_last_response_id(self, company_short_name: str, user_identifier: str) -> Optional[str]:
-        session_key = self._get_session_key(company_short_name, user_identifier)
+    def get_last_response_id(self, company_short_name: str, user_identifier: str, model: str = None) -> Optional[str]:
+        """Returns the last LLM response ID for this user/model combination."""
+        session_key = self._get_session_key(company_short_name, user_identifier, model=model)
         if not session_key:
             return None
-        return RedisSessionManager.hget(session_key, 'last_response_id')
-
-    def save_last_response_id(self, company_short_name: str, user_identifier: str, response_id: str):
-        session_key = self._get_session_key(company_short_name, user_identifier)
+        return RedisSessionManager.hget(session_key, "last_response_id")
+
+    def save_last_response_id(self,
+        company_short_name: str,
+        user_identifier: str,
+        response_id: str,
+        model: str = None,
+    ):
+        """Persists the last LLM response ID for this user/model combination."""
+        session_key = self._get_session_key(company_short_name, user_identifier, model=model)
         if session_key:
-            RedisSessionManager.hset(session_key, 'last_response_id', response_id)
-
-    def save_context_history(self, company_short_name: str, user_identifier: str, context_history: List[Dict]):
-        session_key = self._get_session_key(company_short_name, user_identifier)
+            RedisSessionManager.hset(session_key, "last_response_id", response_id)
+
+    def get_initial_response_id(self,
+        company_short_name: str,
+        user_identifier: str,
+        model: str = None,
+    ) -> Optional[str]:
+        """
+        Returns the initial LLM response ID for this user/model combination.
+        This ID represents the state right after the context was set on the LLM.
+        """
+        session_key = self._get_session_key(company_short_name, user_identifier, model=model)
+        if not session_key:
+            return None
+        return RedisSessionManager.hget(session_key, "initial_response_id")
+
+    def save_initial_response_id(self,
+            company_short_name: str,
+            user_identifier: str,
+            response_id: str,
+            model: str = None,
+    ):
+        """Persists the initial LLM response ID for this user/model combination."""
+        session_key = self._get_session_key(company_short_name, user_identifier, model=model)
+        if session_key:
+            RedisSessionManager.hset(session_key, "initial_response_id", response_id)
+
+    def save_context_history(
+            self,
+            company_short_name: str,
+            user_identifier: str,
+            context_history: List[Dict],
+            model: str = None,
+    ):
+        """Serializes and stores the context history for this user/model combination."""
+        session_key = self._get_session_key(company_short_name, user_identifier, model=model)
         if session_key:
             try:
                 history_json = json.dumps(context_history)
-                RedisSessionManager.hset(session_key, 'context_history', history_json)
+                RedisSessionManager.hset(session_key, "context_history", history_json)
             except (TypeError, ValueError) as e:
-                logging.error(f"Error al serializar context_history para {session_key}: {e}")
-
-    def get_context_history(self, company_short_name: str, user_identifier: str) -> Optional[List[Dict]]:
-        session_key = self._get_session_key(company_short_name, user_identifier)
+                logging.error(f"Error serializing context_history for {session_key}: {e}")
+
+    def get_context_history(
+            self,
+            company_short_name: str,
+            user_identifier: str,
+            model: str = None,
+    ) -> Optional[List[Dict]]:
+        """Reads and deserializes the context history for this user/model combination."""
+        session_key = self._get_session_key(company_short_name, user_identifier, model=model)
         if not session_key:
-            return None
+            return []
 
-        history_json = RedisSessionManager.hget(session_key, 'context_history')
+        history_json = RedisSessionManager.hget(session_key, "context_history")
         if not history_json:
             return []
 
@@ -95,37 +141,61 @@ class UserSessionContextService:
         except json.JSONDecodeError:
             return {}
 
-    def save_context_version(self, company_short_name: str, user_identifier: str, version: str):
-        session_key = self._get_session_key(company_short_name, user_identifier)
+    def save_context_version(self,
+            company_short_name: str,
+            user_identifier: str,
+            version: str,
+            model: str = None,
+        ):
+        """Saves the context version for this user/model combination."""
+        session_key = self._get_session_key(company_short_name, user_identifier, model=model)
         if session_key:
-            RedisSessionManager.hset(session_key, 'context_version', version)
-
-    def get_context_version(self, company_short_name: str, user_identifier: str) -> Optional[str]:
-        session_key = self._get_session_key(company_short_name, user_identifier)
+            RedisSessionManager.hset(session_key, "context_version", version)
+
+    def get_context_version(self,
+            company_short_name: str,
+            user_identifier: str,
+            model: str = None,
+            ) -> Optional[str]:
+        """Returns the context version for this user/model combination."""
+        session_key = self._get_session_key(company_short_name, user_identifier, model=model)
         if not session_key:
             return None
-        return RedisSessionManager.hget(session_key, 'context_version')
-
-    def save_prepared_context(self, company_short_name: str, user_identifier: str, context: str, version: str):
-        """Guarda un contexto de sistema pre-renderizado y su versión, listos para ser enviados al LLM."""
-        session_key = self._get_session_key(company_short_name, user_identifier)
+        return RedisSessionManager.hget(session_key, "context_version")
+
+    def save_prepared_context(self,
+            company_short_name: str,
+            user_identifier: str,
+            context: str,
+            version: str,
+            model: str = None,
+            ):
+        """Stores a pre-rendered system context and its version, ready to be sent to the LLM."""
+        session_key = self._get_session_key(company_short_name, user_identifier, model=model)
         if session_key:
-            RedisSessionManager.hset(session_key, 'prepared_context', context)
-            RedisSessionManager.hset(session_key, 'prepared_context_version', version)
-
-    def get_and_clear_prepared_context(self, company_short_name: str, user_identifier: str) -> tuple:
-        """Obtiene el contexto preparado y su versión, y los elimina para asegurar que se usan una sola vez."""
-        session_key = self._get_session_key(company_short_name, user_identifier)
+            RedisSessionManager.hset(session_key, "prepared_context", context)
+            RedisSessionManager.hset(session_key, "prepared_context_version", version)
+
+    def get_and_clear_prepared_context(self,
+            company_short_name: str,
+            user_identifier: str,
+            model: str = None,
+            ) -> tuple:
+        """
+        Atomically retrieves the prepared context and its version and then deletes them
+        to guarantee they are consumed only once.
+        """
+        session_key = self._get_session_key(company_short_name, user_identifier, model=model)
         if not session_key:
             return None, None
 
         pipe = RedisSessionManager.pipeline()
-        pipe.hget(session_key, 'prepared_context')
-        pipe.hget(session_key, 'prepared_context_version')
-        pipe.hdel(session_key, 'prepared_context', 'prepared_context_version')
+        pipe.hget(session_key, "prepared_context")
+        pipe.hget(session_key, "prepared_context_version")
+        pipe.hdel(session_key, "prepared_context", "prepared_context_version")
         results = pipe.execute()
 
-        # results[0] es el contexto, results[1] es la versión
+        # results[0] is the context, results[1] is the version
         return (results[0], results[1]) if results else (None, None)
 
     # --- Métodos de Bloqueo ---

iatoolkit/static/js/chat_feedback_button.js

@@ -53,7 +53,7 @@ $('#feedbackModal').on('hidden.bs.modal', function () {
     $('.star').removeClass('active');
 });
 
-// Function for the star rating system
+// Tool for the star rating system
 window.gfg = function (rating) {
     $('.star').removeClass('active');
     $('.star').each(function (index) {

iatoolkit/static/js/chat_help_content.js

@@ -59,7 +59,7 @@ $(document).ready(function () {
                 cat.questions.forEach(q => contentHtml += `<li>${q}</li>`);
                 contentHtml += `</ul>`;
             });
-            accordionHtml += createAccordionItem('examples', 'Preguntas de Ejemplo', contentHtml, true);
+            accordionHtml += createAccordionItem('examples', 'Sample questions', contentHtml, true);
         }
 
         if (data.data_sources) {
@@ -68,7 +68,7 @@ $(document).ready(function () {
                 contentHtml += `<dt>${p.source}</dt><dd>${p.description}</dd>`;
             });
             contentHtml += `</dl>`;
-            accordionHtml += createAccordionItem('sources', 'Datos disponibles', contentHtml );
+            accordionHtml += createAccordionItem('sources', 'Data available', contentHtml );
         }
 
         if (data.best_practices) {
@@ -81,7 +81,7 @@ $(document).ready(function () {
                 contentHtml += `</dd>`;
             });
             contentHtml += `</dl>`;
-            accordionHtml += createAccordionItem('practices', 'Mejores Prácticas', contentHtml);
+            accordionHtml += createAccordionItem('practices', 'Best practices', contentHtml);
         }
 
         if (data.capabilities) {
@@ -89,7 +89,7 @@ $(document).ready(function () {
             contentHtml += `<div class="col-md-6"><h6 class="fw-bold">Puede hacer:</h6><ul>${data.capabilities.can_do.map(item => `<li>${item}</li>`).join('')}</ul></div>`;
             contentHtml += `<div class="col-md-6"><h6 class="fw-bold">No puede hacer:</h6><ul>${data.capabilities.cannot_do.map(item => `<li>${item}</li>`).join('')}</ul></div>`;
             contentHtml += `</div>`;
-            accordionHtml += createAccordionItem('capabilities', 'Capacidades y Límites', contentHtml);
+            accordionHtml += createAccordionItem('capabilities', 'Capabilities and limits', contentHtml);
         }
 
         container.html(accordionHtml);

iatoolkit/static/js/chat_main.js

@@ -110,17 +110,51 @@ const handleChatMessage = async function () {
             prompt_name: promptName,
             client_data: clientData,
             files: filesBase64.map(f => ({ filename: f.name, content: f.base64 })),
-            user_identifier: window.user_identifier
+            user_identifier: window.user_identifier,
+            model: (window.currentLlmModel || window.defaultLlmModel || '')
+
         };
 
         const responseData = await callToolkit("/api/llm_query", data, "POST");
         if (responseData && responseData.answer) {
-            const answerSection = $('<div>').addClass('answer-section llm-output').append(responseData.answer);
-            displayBotMessage(answerSection);
+                // CAMBIO:  contenedor principal para la respuesta del bot
+                const botMessageContainer = $('<div>').addClass('bot-message-container');
+
+                // 1. Si hay reasoning_content, agregar el acordeón colapsable
+                if (responseData.reasoning_content) {
+                    const uniqueId = 'reasoning-' + Date.now(); // ID único para el collapse
+
+                    const reasoningBlock = $(`
+                            <div class="reasoning-block">
+                                <button class="reasoning-toggle btn btn-sm btn-link text-decoration-none p-0"
+                                    type="button"
+                                    data-bs-toggle="collapse"
+                                    data-bs-target="#${uniqueId}"
+                                    aria-expanded="false"
+                                    aria-controls="${uniqueId}">
+                                    <i class="bi bi-lightbulb me-1"></i> ${t_js('show_reasoning')}
+                                </button>
+                        
+                                <div class="collapse mt-2" id="${uniqueId}">
+                                    <div class="reasoning-card">
+                                        ${responseData.reasoning_content}
+                                    </div>
+                                </div>
+                            </div>
+                        `);
+                    botMessageContainer.append(reasoningBlock);
+                }
+
+                // 2. Agregar la respuesta final
+                const answerSection = $('<div>').addClass('answer-section llm-output').append(responseData.answer);
+                botMessageContainer.append(answerSection);
+
+                // 3. Mostrar el contenedor completo
+                displayBotMessage(botMessageContainer);
+
         }
     } catch (error) {
         if (error.name === 'AbortError') {
-            console.log('Petición abortada por el usuario.');
 
             // Usando jQuery estándar para construir el elemento ---
             const icon = $('<i>').addClass('bi bi-stop-circle me-2'); // Icono sin "fill" para un look más ligero
@@ -208,7 +242,12 @@ const toggleSendStopButtons = function (showStop) {
  * @returns {Promise<object|null>} The response data or null on error.
  */
 const callToolkit = async function(apiPath, data, method, timeoutMs = 500000) {
-    const url = `${window.iatoolkit_base_url}/${window.companyShortName}${apiPath}`;
+    // normalize the url for avoiding double //
+    const base = (window.iatoolkit_base_url || '').replace(/\/+$/, '');
+    const company = (window.companyShortName || '').replace(/^\/+|\/+$/g, '');
+    const path = apiPath.startsWith('/') ? apiPath : `/${apiPath}`;
+    const url = `${base}/${company}${path}`;
+
 
     abortController = new AbortController();
     const timeoutId = setTimeout(() => abortController.abort(), timeoutMs);
@@ -230,22 +269,35 @@ const callToolkit = async function(apiPath, data, method, timeoutMs = 500000) {
         }
         const response = await fetch(url, fetchOptions);
         clearTimeout(timeoutId);
+
+        // answer is NOT OK (status != 200)
         if (!response.ok) {
             try {
                 // Intentamos leer el error como JSON, que es el formato esperado de nuestra API.
                 const errorData = await response.json();
-                const errorMessage = errorData.error_message || t_js('unknown_server_error'); // <-- Translation
-                const errorIcon = '<i class="bi bi-exclamation-triangle"></i>';
-                const endpointError = $('<div>').addClass('error-section').html(errorIcon + `<p>${errorMessage}</p>`);
-                displayBotMessage(endpointError);
+
+                // if it's a iatoolkit error  (409 o 400 with a message), shot it on the chat
+                if (errorData && (errorData.error_message || errorData.error)) {
+                    const errorMessage = errorData.error_message || errorData.error || t_js('unknown_server_error');
+                    const errorIcon = '<i class="bi bi-exclamation-triangle"></i>';
+                    const endpointError = $('<div>').addClass('error-section').html(errorIcon + `<p>${errorMessage}</p>`);
+                    displayBotMessage(endpointError);
+                } else {
+                    // if there is not message, we show a generic error message
+                    throw new Error(`Server error: ${response.status}`);
+                }
             } catch (e) {
                 // Si response.json() falla, es porque el cuerpo no era JSON (ej. un 502 con HTML).
                 // Mostramos un error genérico y más claro para el usuario.
                 const errorMessage = `Error de comunicación con el servidor (${response.status}). Por favor, intente de nuevo más tarde.`;
                 toastr.error(errorMessage);
             }
+
+            // stop the flow on the calling function
             return null;
         }
+
+        // if the answer is OK
         return await response.json();
     } catch (error) {
         clearTimeout(timeoutId);

iatoolkit/static/js/chat_model_selector.js

@@ -0,0 +1,227 @@
+// src/iatoolkit/static/js/chat_model_selector.js
+// Gestión del selector de modelo LLM en la barra superior.
+
+// Estado global del modelo actual (visible también para otros scripts)
+window.currentLlmModel = window.currentLlmModel || null;
+
+(function () {
+    /**
+     * Lee el modelo guardado en localStorage (si existe y es válido).
+     */
+    function loadStoredModelId() {
+        try {
+            const stored = localStorage.getItem('iatoolkit.selected_llm_model');
+            return stored || null;
+        } catch (e) {
+            return null;
+        }
+    }
+
+    /**
+     * Guarda el modelo seleccionado en localStorage para esta instancia de navegador.
+     * No es crítico: si falla, simplemente no persistimos.
+     */
+    function storeModelId(modelId) {
+        try {
+            if (!modelId) {
+                localStorage.removeItem('iatoolkit.selected_llm_model');
+            } else {
+                localStorage.setItem('iatoolkit.selected_llm_model', modelId);
+            }
+        } catch (e) {
+            // No hacemos nada: fallo silencioso
+        }
+    }
+
+    /**
+     * Devuelve la lista de modelos disponibles desde la variable global.
+     */
+    function getAvailableModels() {
+        const raw = window.availableLlmModels;
+        if (!Array.isArray(raw)) {
+            return [];
+        }
+        return raw.map(m => ({
+            id: m.id,
+            label: m.label || m.id,
+            description: m.description || ''
+        })).filter(m => !!m.id);
+    }
+
+    /**
+     * Inicializa el estado de currentLlmModel usando SIEMPRE la config de company.yaml:
+     * 1) defaultLlmModel (company.yaml)
+     * 2) si no existe o no está en la lista, usa el primer modelo disponible.
+     *
+     * No se lee nada de localStorage en este punto: cada apertura de chat
+     * arranca desde la configuración de la compañía.
+     */
+    function initCurrentModel() {
+        const models = getAvailableModels();
+        const defaultId = (window.defaultLlmModel || '').trim() || null;
+
+        let resolved = null;
+
+        if (defaultId && models.some(m => m.id === defaultId)) {
+            resolved = defaultId;
+        } else if (models.length > 0) {
+            resolved = models[0].id;
+        }
+
+        window.currentLlmModel = resolved;
+        return resolved;
+    }
+
+    /**
+     * Pinta la lista de modelos en el popup y marca el seleccionado.
+     */
+    function renderModelList() {
+        const listEl = document.getElementById('llm-model-list');
+        if (!listEl) return;
+
+        const models = getAvailableModels();
+        const activeId = window.currentLlmModel;
+        listEl.innerHTML = '';
+
+        if (!models.length) {
+            const emptyItem = document.createElement('div');
+            emptyItem.className = 'list-group-item small text-muted';
+            emptyItem.textContent = 'No hay modelos configurados.';
+            listEl.appendChild(emptyItem);
+            return;
+        }
+
+        models.forEach(model => {
+            const item = document.createElement('button');
+            item.type = 'button';
+            item.className = 'list-group-item list-group-item-action small';
+
+            const isActive = model.id === activeId;
+            if (isActive) {
+                item.classList.add('active');
+            }
+
+            item.innerHTML = `
+                <div class="d-flex justify-content-between align-items-center">
+                    <div>
+                        <div class="fw-semibold">${model.label}</div>
+                        ${model.description
+                ? `<div class="text-muted" style="font-size: 0.8rem;">${model.description}</div>`
+                : ''
+            }
+                    </div>
+                    ${isActive ? '<i class="bi bi-check-lg ms-2"></i>' : ''}
+                </div>
+            `;
+
+            item.addEventListener('click', () => {
+                selectModel(model.id);
+            });
+
+            listEl.appendChild(item);
+        });
+    }
+
+    /**
+     * Actualiza el label del botón principal con el modelo actual.
+     */
+    function updateButtonLabel() {
+        const labelEl = document.getElementById('llm-model-button-label');
+        if (!labelEl) return;
+
+        const models = getAvailableModels();
+        const activeId = window.currentLlmModel;
+        const activeModel = models.find(m => m.id === activeId);
+
+        if (activeModel) {
+            labelEl.textContent = activeModel.label;
+        } else if (window.defaultLlmModel) {
+            labelEl.textContent = window.defaultLlmModel;
+        } else {
+            labelEl.textContent = 'Modelo IA';
+        }
+    }
+
+    /**
+     * Selecciona un modelo: actualiza estado global, UI y almacenamiento local.
+     */
+    function selectModel(modelId) {
+        if (!modelId) return;
+
+        const models = getAvailableModels();
+        const exists = models.some(m => m.id === modelId);
+        if (!exists) return;
+
+        window.currentLlmModel = modelId;
+        storeModelId(modelId);
+        updateButtonLabel();
+        renderModelList();
+        hidePopup();
+
+        if (typeof toastr !== 'undefined') {
+            toastr.info(`Modelo actualizado a "${models.find(m => m.id === modelId).label}".`);
+        }
+    }
+
+    /**
+     * Muestra/oculta el popup anclado al botón.
+     */
+    function togglePopup() {
+        const popup = document.getElementById('llm-model-popup');
+        const btn = document.getElementById('llm-model-button');
+        if (!popup || !btn) return;
+
+        const isVisible = popup.style.display === 'block';
+
+        if (isVisible) {
+            hidePopup();
+        } else {
+            const rect = btn.getBoundingClientRect();
+            popup.style.display = 'block';
+
+            // Posicionamos justo debajo del botón, alineado a la izquierda
+            popup.style.top = `${rect.bottom + window.scrollY + 4}px`;
+            popup.style.left = `${rect.left + window.scrollX}px`;
+        }
+    }
+
+    function hidePopup() {
+        const popup = document.getElementById('llm-model-popup');
+        if (popup) {
+            popup.style.display = 'none';
+        }
+    }
+
+    /**
+     * Cierra el popup si el usuario hace click fuera.
+     */
+    function setupOutsideClickHandler() {
+        document.addEventListener('click', (event) => {
+            const popup = document.getElementById('llm-model-popup');
+            const btn = document.getElementById('llm-model-button');
+            if (!popup || !btn) return;
+
+            if (popup.style.display !== 'block') return;
+
+            if (!popup.contains(event.target) && !btn.contains(event.target)) {
+                hidePopup();
+            }
+        });
+    }
+
+    document.addEventListener('DOMContentLoaded', () => {
+        // Inicializar estado inicial del modelo
+        initCurrentModel();
+        updateButtonLabel();
+        renderModelList();
+        setupOutsideClickHandler();
+
+        const btn = document.getElementById('llm-model-button');
+        if (btn) {
+            btn.addEventListener('click', (event) => {
+                event.stopPropagation();
+                togglePopup();
+            });
+        }
+    });
+})();

iatoolkit/static/js/chat_onboarding_button.js

@@ -45,7 +45,7 @@
       if (elTitle) elTitle.textContent = c.title || '';
       if (elText) elText.innerHTML = c.text || '';
       if (elExample && c.example) {
-          elExample.innerHTML = ('Ejemplo: ' + c.example) || '';
+          elExample.innerHTML = ('Example ' + ': ' + c.example) || '';
       }
       else
           elExample.innerHTML = '';

iatoolkit/static/js/chat_reload_button.js

@@ -18,7 +18,10 @@ $(document).ready(function () {
 
         // 2. prepare the api parameters
         const apiPath = '/api/init-context';
-        const payload = {'user_identifier': window.user_identifier};
+        const payload = {
+            'user_identifier': window.user_identifier,
+            'model': (window.currentLlmModel || window.defaultLlmModel || '')
+            };
 
         // 3. make the call to callToolkit
         const data = await callToolkit(apiPath, payload, 'POST');