iatoolkit 0.4.2__py3-none-any.whl → 0.66.2__py3-none-any.whl

iatoolkit/static/js/chat_main.js

@@ -0,0 +1,364 @@
+// Global variables for request management
+let isRequestInProgress = false;
+let abortController = null;
+let selectedPrompt = null; // Will hold a lightweight prompt object
+
+$(document).ready(function () {
+    // Si viene un Token retornado por login con APY-KEY se gatilla el redeem a una sesion de flask
+        if (window.redeemToken) {
+            const url = '/api/redeem_token';
+            // No await: dejamos que callToolkit maneje todo internamente
+            callToolkit(url, {'token': window.redeemToken}, "POST").catch(() => {});
+        }
+
+    const layoutContainer = document.querySelector('.chat-layout-container');
+    const promptAssistantCollapse = document.getElementById('prompt-assistant-collapse');
+
+    if (layoutContainer && promptAssistantCollapse) {
+        promptAssistantCollapse.addEventListener('show.bs.collapse', function () {
+            layoutContainer.classList.add('prompt-assistant-open');
+            setTimeout(() => {
+                window.scrollTo({ top: document.body.scrollHeight, behavior: 'smooth' });
+            }, 300);
+        });
+
+        promptAssistantCollapse.addEventListener('hide.bs.collapse', function () {
+            layoutContainer.classList.remove('prompt-assistant-open');
+        });
+    }
+
+    // --- chat main event hadlers ---
+    $('#send-button').on('click', handleChatMessage);
+    $('#stop-button').on('click', abortCurrentRequest);
+    if (window.sendButtonColor)
+        $('#send-button i').css('color', window.sendButtonColor);
+
+
+    // Handles Enter key press to send a message
+    const questionTextarea = $('#question');
+    questionTextarea.on('keypress', function (event) {
+        if (event.key === 'Enter' && !event.shiftKey) {
+            event.preventDefault();
+            handleChatMessage();
+        }
+    });
+
+    // Handles auto-resizing and enables the send button on input
+    questionTextarea.on('input', function () {
+        autoResizeTextarea(this);
+        // If the user types, it overrides any prompt selection
+        if (selectedPrompt) {
+            resetPromptSelection();
+        }
+        updateSendButtonState();
+    });
+
+    // Set the initial disabled state of the send button
+    updateSendButtonState();
+
+});
+
+
+/**
+ * Main function to handle sending a chat message.
+ */
+const handleChatMessage = async function () {
+    if (isRequestInProgress || $('#send-button').hasClass('disabled')) {
+        return;
+    }
+
+    isRequestInProgress = true;
+    toggleSendStopButtons(true);
+
+    try {
+        const question = $('#question').val().trim();
+        const promptName = selectedPrompt ? selectedPrompt.prompt : null;
+
+        let displayMessage = question;
+        let isEditable = true;
+        const clientData = {};
+
+        if (selectedPrompt) {
+            displayMessage = selectedPrompt.description;
+            isEditable = false;
+
+            (selectedPrompt.custom_fields || []).forEach(field => {
+                const value = $('#' + field.data_key + '-id').val().trim();
+                if (value) {
+                    clientData[field.data_key] = value;
+                }
+            });
+
+            const paramsString = Object.values(clientData).join(', ');
+            if (paramsString) { displayMessage += `: ${paramsString}`; }
+        }
+
+        // Simplificado: Si no hay mensaje, el 'finally' se encargará de limpiar.
+        if (!displayMessage) {
+            return;
+        }
+
+        displayUserMessage(displayMessage, isEditable, question);
+        showSpinner();
+        resetAllInputs();
+
+        const files = window.filePond.getFiles();
+        const filesBase64 = await Promise.all(files.map(fileItem => toBase64(fileItem.file)));
+
+        const data = {
+            question: question,
+            prompt_name: promptName,
+            client_data: clientData,
+            files: filesBase64.map(f => ({ filename: f.name, content: f.base64 })),
+            user_identifier: window.user_identifier
+        };
+
+        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);
+        }
+    } 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
+            const textSpan = $('<span>').text('La generación de la respuesta ha sido detenida.');
+
+            const abortMessage = $('<div>')
+                .addClass('system-message')
+                .append(icon)
+                .append(textSpan);
+
+            displayBotMessage(abortMessage);
+        } else {
+            console.error("Error in handleChatMessage:", error);
+            const errorSection = $('<div>').addClass('error-section').append('<p>Ocurrió un error al procesar la solicitud.</p>');
+            displayBotMessage(errorSection);
+        }
+    } finally {
+        // Este bloque se ejecuta siempre, garantizando que el estado se limpie.
+        isRequestInProgress = false;
+        hideSpinner();
+        toggleSendStopButtons(false);
+        updateSendButtonState();
+        if (window.filePond) {
+             window.filePond.removeFiles();
+        }
+    }
+};
+
+
+/**
+ * Resets all inputs to their initial state.
+ */
+function resetAllInputs() {
+    resetPromptSelection();
+    $('#question').val('');
+    autoResizeTextarea($('#question')[0]);
+
+    const promptCollapseEl = document.getElementById('prompt-assistant-collapse');
+    const promptCollapse = bootstrap.Collapse.getInstance(promptCollapseEl);
+    if (promptCollapse) {
+        promptCollapse.hide();
+    }
+
+    updateSendButtonState();
+}
+
+/**
+ * Enables or disables the send button based on whether there's content
+ * in the textarea or a prompt has been selected.
+ */
+function updateSendButtonState() {
+    const question = $('#question').val().trim();
+    const isPromptSelected = selectedPrompt !== null;
+
+    if (isPromptSelected || question) {
+        $('#send-button').removeClass('disabled');
+    } else {
+        $('#send-button').addClass('disabled');
+    }
+}
+
+/**
+ * Auto-resizes the textarea to fit its content.
+ */
+function autoResizeTextarea(element) {
+    element.style.height = 'auto';
+    element.style.height = (element.scrollHeight) + 'px';
+}
+
+/**
+ * Toggles the main action button between 'Send' and 'Stop'.
+ * @param {boolean} showStop - If true, shows the Stop button. Otherwise, shows the Send button.
+ */
+const toggleSendStopButtons = function (showStop) {
+    $('#send-button-container').toggle(!showStop);
+    $('#stop-button-container').toggle(showStop);
+};
+
+/**
+ * Generic function to make API calls to the backend.
+ * @param {string} apiPath - The API endpoint path.
+ * @param {object} data - The data payload to send.
+ * @param {string} method - The HTTP method (e.g., 'POST').
+ * @param {number} timeoutMs - Timeout in milliseconds.
+ * @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}`;
+
+    abortController = new AbortController();
+    const timeoutId = setTimeout(() => abortController.abort(), timeoutMs);
+
+    try {
+        const fetchOptions = {
+                method: method,
+                signal: abortController.signal,
+                credentials: 'include'
+            };
+
+        // Solo agrega body si el método lo soporta y hay datos
+        const methodUpper = (method || '').toUpperCase();
+        const canHaveBody = !['GET', 'HEAD'].includes(methodUpper);
+        if (canHaveBody && data !== undefined && data !== null) {
+            fetchOptions.body = JSON.stringify(data);
+            fetchOptions.headers = {"Content-Type": "application/json"};
+
+        }
+        const response = await fetch(url, fetchOptions);
+
+        clearTimeout(timeoutId);
+
+        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);
+            } 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.`;
+                const errorIcon = '<i class="bi bi-exclamation-triangle"></i>';
+                const infrastructureError = $('<div>').addClass('error-section').html(errorIcon + `<p>${errorMessage}</p>`);
+                displayBotMessage(infrastructureError);
+            }
+            return null;
+        }
+        return await response.json();
+    } catch (error) {
+        clearTimeout(timeoutId);
+        if (error.name === 'AbortError') {
+            throw error; // Re-throw to be handled by handleChatMessage
+        } else {
+            // Log detallado en consola
+                console.error('Network error in callToolkit:', {
+                    url,
+                    method,
+                    error,
+                    message: error?.message,
+                    stack: error?.stack,
+                });
+            const friendlyMessage = t_js('network_error');
+            const errorIcon = '<i class="bi bi-exclamation-triangle"></i>';
+            const commError = $('<div>').addClass('error-section').html(errorIcon + `<p>${friendlyMessage}</p>`);
+            displayBotMessage(commError);
+        }
+        return null;
+    }
+};
+
+
+/**
+ * Displays the user's message in the chat container.
+ * @param {string} message - The full message string to display.
+ * @param {boolean} isEditable - Determines if the edit icon should be shown.
+ * @param {string} originalQuestion - The original text to put back in the textarea for editing.
+ */
+const displayUserMessage = function(message, isEditable, originalQuestion) {
+    const chatContainer = $('#chat-container');
+    const userMessage = $('<div>').addClass('message shadow-sm');
+    const messageText = $('<span>').text(message);
+
+    userMessage.append(messageText);
+
+    if (isEditable) {
+        const editIcon = $('<i>').addClass('p-2 bi bi-pencil-fill edit-icon edit-pencil').attr('title', 'Edit query').on('click', function () {
+            $('#question').val(originalQuestion)
+            autoResizeTextarea($('#question')[0]);
+            $('#send-button').removeClass('disabled');
+
+            if (window.innerWidth > 768)
+                $('#question').focus();
+        });
+        userMessage.append(editIcon);
+    }
+    chatContainer.append(userMessage);
+    chatContainer.scrollTop(chatContainer[0].scrollHeight);
+};
+
+/**
+ * Appends a message from the bot to the chat container.
+ * @param {jQuery} section - The jQuery object to append.
+ */
+function displayBotMessage(section) {
+    const chatContainer = $('#chat-container');
+    chatContainer.append(section);
+    chatContainer.scrollTop(chatContainer[0].scrollHeight);
+}
+
+/**
+ * Aborts the current in-progress API request.
+ */
+const abortCurrentRequest = function () {
+    if (isRequestInProgress && abortController) {
+        abortController.abort();
+    }
+};
+
+/**
+ * Shows the loading spinner in the chat.
+ */
+const showSpinner = function () {
+    if ($('#spinner').length) return;
+    const accessibilityClass = (typeof bootstrap !== 'undefined') ? 'visually-hidden' : 'sr-only';
+    const spinnerText = t_js('loading');
+    const spinner = $(`
+        <div id="spinner" style="display: flex; align-items: center; justify-content: start; margin: 10px 0; padding: 10px;">
+            <div class="spinner-border" role="status" style="width: 1.5rem; height: 1.5rem; margin-right: 15px;">
+                <span class="${accessibilityClass}">Loading...</span>
+            </div>
+            <span style="font-weight: bold; font-size: 15px;">${spinnerText}</span>
+        </div>
+    `);
+    $('#chat-container').append(spinner).scrollTop($('#chat-container')[0].scrollHeight);
+};
+
+/**
+ * Hides the loading spinner.
+ */
+function hideSpinner() {
+    $('#spinner').fadeOut(function () {
+        $(this).remove();
+    });
+}
+
+/**
+ * Converts a File object to a Base64 encoded string.
+ * @param {File} file The file to convert.
+ * @returns {Promise<{name: string, base64: string}>}
+ */
+function toBase64(file) {
+    return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onload = () => resolve({name: file.name, base64: reader.result.split(",")[1]});
+        reader.onerror = reject;
+        reader.readAsDataURL(file);
+    });
+}
+

iatoolkit/static/js/chat_onboarding_button.js

@@ -0,0 +1,97 @@
+(function (global) {
+  function qs(root, sel) { return (typeof sel === 'string') ? root.querySelector(sel) : sel; }
+
+  function createDots(container, count, activeIdx, activeColor) {
+    container.innerHTML = '';
+    for (let i = 0; i < count; i++) {
+      const d = document.createElement('div');
+      if (i === activeIdx) d.classList.add('active');
+      d.style.width = '10px';
+      d.style.height = '10px';
+      d.style.borderRadius = '50%';
+      d.style.backgroundColor = i === activeIdx ? (activeColor || 'var(--brand-primary-color, #FF5100)') : '#ddd';
+      d.style.transition = 'background-color .3s';
+      container.appendChild(d);
+    }
+  }
+
+  function initOnboarding(opts) {
+    const {
+      mode = 'modal',
+      cards = [],
+      ui = {},
+      autoRotateMs = 5000,
+      shell = {}
+    } = opts;
+
+    const root = document;
+    const elIcon = qs(root, ui.icon);
+    const elTitle = qs(root, ui.title);
+    const elText = qs(root, ui.text);
+    const elDots = qs(root, ui.dots);
+    const elPrev = qs(root, ui.prev);
+    const elNext = qs(root, ui.next);
+
+    let idx = 0;
+    let autoTimer = null;
+
+    function hasCards() { return Array.isArray(cards) && cards.length > 0; }
+
+    function render() {
+      if (!hasCards()) return;
+      const c = cards[idx] || {};
+      if (elIcon) elIcon.innerHTML = `<i class="${c.icon || 'bi bi-lightbulb'}"></i>`;
+      if (elTitle) elTitle.textContent = c.title || '';
+      if (elText) elText.innerHTML = c.text || '';
+      if (elDots) createDots(elDots, cards.length, idx);
+    }
+
+    function next() { if (!hasCards()) return; idx = (idx + 1) % cards.length; render(); }
+    function prev() { if (!hasCards()) return; idx = (idx - 1 + cards.length) % cards.length; render(); }
+
+    function startAuto() {
+      stopAuto();
+      if (!hasCards()) return;
+      autoTimer = setInterval(next, autoRotateMs);
+    }
+    function stopAuto() { if (autoTimer) { clearInterval(autoTimer); autoTimer = null; } }
+
+    function setupShellIfNeeded() {
+      if (mode !== 'shell') return;
+      const loader = ui.loader ? qs(root, ui.loader) : null;
+      const container = ui.container ? qs(root, ui.container) : null;
+      if (!container || !shell.iframeSrc) return;
+
+      const iframe = document.createElement('iframe');
+      iframe.src = shell.iframeSrc;
+      iframe.style.width = '100%';
+      iframe.style.height = '100%';
+      iframe.style.border = 'none';
+      iframe.style.display = 'none';
+
+      iframe.onload = function () {
+        iframe.style.display = 'block';
+        if (loader) {
+          loader.style.opacity = '0';
+          setTimeout(() => loader.style.display = 'none', 500);
+        }
+      };
+      container.appendChild(iframe);
+    }
+
+    if (elPrev) elPrev.addEventListener('click', () => { prev(); startAuto(); });
+    if (elNext) elNext.addEventListener('click', () => { next(); startAuto(); });
+
+    function start() {
+      idx = 0;
+      render();
+      startAuto();
+      if (mode === 'shell') setupShellIfNeeded();
+    }
+
+    return { start, stop: stopAuto, next, prev, hasCards };
+  }
+
+  // Export global
+  global.initOnboarding = initOnboarding;
+})(window);

iatoolkit/static/js/chat_prompt_manager.js

@@ -0,0 +1,94 @@
+$(document).ready(function () {
+// --- PROMPT ASSISTANT FUNCTIONALITY ---
+    const $promptCollapse = $('#prompt-assistant-collapse');
+
+    if ($promptCollapse.length) {
+        $promptCollapse.on('shown.bs.collapse', function () {
+            // Scroll to bottom smoothly when the collapse is shown
+            $('html, body').animate(
+                { scrollTop: $(document).height() },
+                'slow'
+            );
+        });
+    }
+
+    $('.input-area').on('click', '.dropdown-menu a.dropdown-item', function (event) {
+        event.preventDefault();
+        const promptData = $(this).data();
+
+        const promptObject = {
+            prompt: promptData.promptName,
+            description: promptData.promptDescription,
+            custom_fields: typeof promptData.customFields === 'string' ? JSON.parse(promptData.customFields) : promptData.customFields
+        };
+        selectPrompt(promptObject);
+    });
+
+    // Handles the 'clear' button for the prompt selector
+    $('#clear-selection-button').on('click', function() {
+        resetPromptSelection();
+        updateSendButtonState();
+    });
+});
+
+/**
+ * Handles the selection of a prompt from the dropdown.
+ * @param {object} prompt The prompt object read from data attributes.
+ */
+function selectPrompt(prompt) {
+    selectedPrompt = prompt;
+
+    // Update the dropdown button to show the selected prompt's description
+    $('#prompt-select-button').text(prompt.description).addClass('item-selected');
+    $('#clear-selection-button').show();
+
+    // Clear the main textarea, as we are now in "prompt mode"
+    $('#question').val('');
+    autoResizeTextarea($('#question')[0]); // Reset height after clearing
+
+    // Store values in hidden fields for backward compatibility or other uses
+    $('#prompt-select-value').val(prompt.prompt);
+    $('#prompt-select-description').val(prompt.description);
+
+    // Render the dynamic input fields required by the selected prompt
+    renderDynamicInputs(prompt.custom_fields || []);
+    updateSendButtonState();
+}
+
+/**
+ * Resets the prompt selection and clears associated UI elements.
+ */
+function resetPromptSelection() {
+    selectedPrompt = null;
+
+    $('#prompt-select-button').text('Prompts disponibles ....').removeClass('item-selected');
+    $('#clear-selection-button').hide();
+    $('#prompt-select-value').val('');
+    $('#prompt-select-description').val('');
+
+    // Clear any dynamically generated input fields
+    $('#dynamic-inputs-container').empty();
+}
+
+/**
+ * Renders the custom input fields for the selected prompt.
+ * @param {Array<object>} fields The array of custom field configurations.
+ */
+function renderDynamicInputs(fields) {
+    const container = $('#dynamic-inputs-container');
+    container.empty();
+
+    const row = $('<div class="row g-2"></div>');
+    fields.forEach(field => {
+        const colDiv = $('<div class="col-md"></div>');
+        const formFloating = $('<div class="form-floating"></div>');
+        const input = $(`<input type="${field.type || 'text'}" class="form-control form-control-soft" id="${field.data_key}-id" ">`);
+        const label = $(`<label for="${field.data_key}-id">${field.label}</label>`);
+
+        formFloating.append(input, label);
+        colDiv.append(formFloating);
+        row.append(colDiv);
+    });
+
+    container.append(row);
+}

iatoolkit/static/js/chat_reload_button.js

@@ -0,0 +1,35 @@
+$(document).ready(function () {
+    $('#force-reload-button').on('click', function() {
+        reloadButton(this);
+     });
+
+    async function reloadButton(button) {
+        const originalIconClass = 'bi bi-arrow-clockwise';
+        const spinnerIconClass = 'spinner-border spinner-border-sm';
+
+        // Configuración de Toastr para que aparezca abajo a la derecha
+        toastr.options = {"positionClass": "toast-bottom-right", "preventDuplicates": true};
+
+        // 1. Deshabilitar y mostrar spinner
+        button.disabled = true;
+        const icon = button.querySelector('i');
+        icon.className = spinnerIconClass;
+        toastr.info(t_js('reload_init'));
+
+        // 2. prepare the api parameters
+        const apiPath = '/api/init-context';
+        const payload = {'user_identifier': window.user_identifier};
+
+        // 3. make the call to callToolkit
+        const data = await callToolkit(apiPath, payload, 'POST');
+        if (data) {
+            if (data.status === 'OK')
+                toastr.success(data.message || 'Contexto reloaded.');
+            else
+                toastr.error(data.error_message || 'error during reload');
+        }
+
+        button.disabled = false;
+        icon.className = originalIconClass;
+    }
+});