iatoolkit 0.91.1__py3-none-any.whl → 1.7.0__py3-none-any.whl

iatoolkit/services/user_session_context_service.py

@@ -15,73 +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)
+            RedisSessionManager.hset(session_key, "last_response_id", response_id)
 
-    def get_initial_response_id(self, company_short_name: str, user_identifier: str) -> Optional[str]:
+    def get_initial_response_id(self,
+        company_short_name: str,
+        user_identifier: str,
+        model: str = None,
+    ) -> Optional[str]:
         """
-        Obtiene el ID de respuesta inicial desde la sesión del usuario.
-        Este ID corresponde al estado del LLM justo después de haber configurado el contexto.
+        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)
+        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):
-        """
-        Guarda el ID de respuesta inicial en la sesión del usuario.
-        """
-        session_key = self._get_session_key(company_short_name, user_identifier)
+        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]):
-        session_key = self._get_session_key(company_short_name, user_identifier)
+            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 []
 
@@ -113,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_main.js

@@ -110,13 +110,48 @@ 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') {
@@ -207,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);

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 = (t_js('example') + ': ' + 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');

iatoolkit/static/styles/chat_iatoolkit.css

@@ -499,5 +499,61 @@ li {
     cursor: pointer;
 }
 
-
-
+  /* Popup de selección de modelo LLM - versión minimalista, sin branding de fondo */
+    .llm-model-popup {
+        background-color: #f9fafb;           /* Fondo claro neutro */
+        border-radius: 0.5rem;
+        border: 1px solid #e5e7eb;          /* Borde gris muy suave */
+        color: #111827;                     /* Texto principal en gris casi negro */
+        box-shadow: 0 10px 30px rgba(15, 23, 42, 0.12); /* Sombra suave y limpia */
+    }
+
+    .llm-model-popup .card-body {
+        padding-left: 0.9rem;
+        padding-right: 0.9rem;
+    }
+
+    .llm-model-popup .llm-model-subtitle {
+        font-size: 0.8rem;
+        color: #6b7280;                     /* Gris medio para el subtítulo */
+    }
+
+    .llm-model-popup .list-group-item {
+        border: none;
+        padding-top: 0.4rem;
+        padding-bottom: 0.4rem;
+        background-color: transparent;
+        color: inherit;
+        border-radius: 0.35rem;
+        transition:
+            background-color 0.15s ease-in-out,
+            transform 0.1s ease-in-out,
+            box-shadow 0.15s ease-in-out;
+    }
+
+    /* Descripción del modelo: mismo color que el nombre, pero un poco más suave */
+    .llm-model-popup .list-group-item .text-muted {
+        color: currentColor !important;
+        opacity: 0.75;
+        font-size: 0.8rem;
+    }
+
+    /* Hover más visible, pero manteniendo el estilo minimalista */
+    .llm-model-popup .list-group-item:hover {
+        background-color: #e5e7eb;          /* Gris claro para resaltar bien */
+        transform: translateX(2px);
+        box-shadow: 0 2px 6px rgba(15, 23, 42, 0.12);
+    }
+
+    /* Item activo: resalta con el primario, pero fondo muy claro */
+    .llm-model-popup .list-group-item.active {
+        background-color: #eef2ff;          /* Azul/gris muy claro tipo focus */
+        color: var(--brand-primary-color, #4C6A8D);
+        border: 1px solid var(--brand-primary-color, #4C6A8D);
+        box-shadow: 0 0 0 1px rgba(37, 99, 235, 0.2);
+    }
+
+    .llm-model-popup .list-group-item.active .text-muted {
+        color: currentColor !important;
+        opacity: 0.85;
+    }

iatoolkit/static/styles/llm_output.css

@@ -1,7 +1,7 @@
 /* BLOQUE GENERAL */
 .llm-output {
   margin: 0;
-  padding: 20px;
+  padding: 14px;
   font-family: Arial, sans-serif;
   font-size: 16px;
   line-height: 1.5;
@@ -113,3 +113,36 @@
 .nowrap {
     white-space: nowrap;
   }
+
+/* =========================================================
+   REASONING BLOCK (LLM)
+   ========================================================= */
+
+.reasoning-block {
+}
+
+/* Botón de mostrar razonamiento */
+.reasoning-toggle {
+  font-size: 13px;
+  color: #6c757d; /* text-secondary */
+}
+
+.reasoning-toggle:hover {
+  color: #495057;
+  text-decoration: underline;
+}
+
+/* Contenedor del reasoning */
+.reasoning-card {
+  background-color: #f8f9fa;            /* bg-light */
+  border-left: 3px solid #6c757d;        /* border-secondary */
+  padding: 10px 14px;
+  font-size: 14px;                      /* consistente con llm-output */
+  line-height: 1.5;
+  color: #555;
+  white-space: pre-wrap;
+  max-height: 300px;
+  overflow-y: auto;
+  font-family: inherit;                 /* 👈 clave: usa la misma fuente base */
+}
+