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

iatoolkit/services/sql_service.py

@@ -3,13 +3,13 @@
 #
 # IAToolkit is open source software.
 
+from iatoolkit.common.interfaces.database_provider import DatabaseProvider
 from iatoolkit.repositories.database_manager import DatabaseManager
-from iatoolkit.common.util import Utility
 from iatoolkit.services.i18n_service import I18nService
 from iatoolkit.common.exceptions import IAToolkitException
-from sqlalchemy import text
-from sqlalchemy.exc import SQLAlchemyError
+from iatoolkit.common.util import Utility
 from injector import inject, singleton
+from typing import Callable
 import json
 import logging
 
@@ -28,91 +28,124 @@ class SqlService:
         self.util = util
         self.i18n_service = i18n_service
 
-        # Cache for database connections
-        self._db_connections: dict[str, DatabaseManager] = {}
+        # Cache for database providers. Key is tuple: (company_short_name, db_name)
+        # Value is the abstract interface DatabaseProvider
+        self._db_connections: dict[tuple[str, str], DatabaseProvider] = {}
+
+        # cache for database schemas. Key is tuple: (company_short_name, db_name)
+        self._db_schemas: dict[tuple[str, str], str] = {}
+
+        # Registry of factory functions.
+        # Format: {'connection_type': function(config_dict) -> DatabaseProvider}
+        self._provider_factories: dict[str, Callable[[dict], DatabaseProvider]] = {}
+
+        # Register the default 'direct' strategy (SQLAlchemy)
+        self.register_provider_factory('direct', self._create_direct_connection)
+
+    def register_provider_factory(self, connection_type: str, factory: Callable[[dict], DatabaseProvider]):
+        """
+        Allows plugins (Enterprise) to register new connection types.
+        """
+        self._provider_factories[connection_type] = factory
+
+    def _create_direct_connection(self, config: dict) -> DatabaseProvider:
+        """Default factory for standard SQLAlchemy connections."""
+        uri = config.get('db_uri') or config.get('DATABASE_URI')
+        schema = config.get('schema')
+        if not uri:
+            raise IAToolkitException(IAToolkitException.ErrorType.DATABASE_ERROR,
+                                     "Missing db_uri for direct connection")
+        return DatabaseManager(uri, schema=schema, register_pgvector=False)
 
-    def register_database(self, db_uri: str, db_name: str, schema: str | None = None):
+    def register_database(self, company_short_name: str, db_name: str, config: dict):
         """
-        Creates and caches a DatabaseManager instance for a given database name and URI.
-        If a database with the same name is already registered, it does nothing.
+        Creates and caches a DatabaseProvider instance based on the configuration.
         """
-        if db_name in self._db_connections:
+        key = (company_short_name, db_name)
+
+        # Determine connection type (default to 'direct')
+        conn_type = config.get('connection_type', 'direct')
+        logging.info(f"Registering DB '{db_name}' ({conn_type}) for company '{company_short_name}'")
+
+        factory = self._provider_factories.get(conn_type)
+        if not factory:
+            logging.error(f"Unknown connection type '{conn_type}' for DB '{db_name}'. Skipping.")
             return
 
-        logging.info(f"Registering and creating connection for database: '{db_name}' (schema: {schema})")
+        try:
+            # Create the provider using the appropriate factory
+            provider_instance = factory(config)
+            self._db_connections[key] = provider_instance
+
+            # save the db_schema
+            self._db_schemas[key] = config.get('schema', 'public')
+        except Exception as e:
+            logging.error(f"Failed to register DB '{db_name}': {e}")
+            # We don't raise here to allow other DBs to load if one fails
 
-        # create the database connection and save it on the cache
-        db_manager = DatabaseManager(db_uri, schema=schema, register_pgvector=False)
-        self._db_connections[db_name] = db_manager
+    def get_db_names(self, company_short_name: str) -> list[str]:
+        """
+        Returns list of logical database names available ONLY for the specified company.
+        """
+        return [db for (co, db) in self._db_connections.keys() if co == company_short_name]
 
-    def get_database_manager(self, db_name: str) -> DatabaseManager:
+    def get_database_provider(self, company_short_name: str, db_name: str) -> DatabaseProvider:
         """
-        Retrieves a registered DatabaseManager instance from the cache.
+        Retrieves a registered DatabaseProvider instance using the composite key.
+        Replaces the old 'get_database_manager'.
         """
+        key = (company_short_name, db_name)
         try:
-            return self._db_connections[db_name]
+            return self._db_connections[key]
         except KeyError:
-            logging.error(f"Attempted to access unregistered database: '{db_name}'")
+            logging.error(
+                f"Attempted to access unregistered database: '{db_name}' for company '{company_short_name}'"
+            )
             raise IAToolkitException(
                 IAToolkitException.ErrorType.DATABASE_ERROR,
-                f"Database '{db_name}' is not registered with the SqlService."
+                f"Database '{db_name}' is not registered for this company."
             )
 
-    def exec_sql(self, company_short_name: str,
-                 database: str,
-                 query: str,
-                 format: str = 'json',
-                 commit: bool = False):
+    def exec_sql(self, company_short_name: str, **kwargs):
         """
-        Executes a raw SQL statement against a registered database.
-
-        Args:
-            company_short_name: The company identifier (for logging/context).
-            database: The logical name of the database to query.
-            query: The SQL statement to execute.
-            format: The output format ('json' or 'dict'). Only relevant for SELECT queries.
-            commit: Whether to commit the transaction immediately after execution.
-                    Use True for INSERT/UPDATE/DELETE statements.
-
-        Returns:
-            - A JSON string or list of dicts for SELECT queries.
-            - A dictionary {'rowcount': N} for non-returning statements (INSERT/UPDATE) if not using RETURNING.
+        Executes a raw SQL statement against a registered database provider.
+        Delegates the actual execution details to the provider implementation.
         """
-        try:
-            # 1. Get the database manager from the cache
-            db_manager = self.get_database_manager(database)
-            session = db_manager.get_session()
-
-            # 2. Execute the SQL statement
-            result = session.execute(text(query))
+        database_name = kwargs.get('database_key')
+        query = kwargs.get('query')
+        format = kwargs.get('format', 'json')
+        commit = kwargs.get('commit')
 
-            # 3. Handle Commit
-            if commit:
-                session.commit()
+        if not database_name:
+            raise IAToolkitException(IAToolkitException.ErrorType.DATABASE_ERROR,
+                                     'missing database_name in call to exec_sql')
 
-            # 4. Process Results
-            # Check if the query returns rows (e.g., SELECT or INSERT ... RETURNING)
-            if result.returns_rows:
-                cols = result.keys()
-                rows_context = [dict(zip(cols, row)) for row in result.fetchall()]
+        try:
+            # 1. Get the abstract provider (could be Direct or Bridge)
+            provider = self.get_database_provider(company_short_name, database_name)
+            db_schema = self._db_schemas[(company_short_name, database_name)]
 
-                if format == 'dict':
-                    return rows_context
+            # 2. Delegate execution
+            # The provider returns a clean List[Dict] or Dict result
+            result_data = provider.execute_query(query=query, commit=commit)
 
-                # serialize the result
-                return json.dumps(rows_context, default=self.util.serialize)
+            # 3. Handle Formatting (Service layer responsibility)
+            if format == 'dict':
+                return result_data
 
-            # For statements that don't return rows (standard UPDATE/DELETE)
-            return {'rowcount': result.rowcount}
+            # Serialize the result
+            return json.dumps(result_data, default=self.util.serialize)
 
         except IAToolkitException:
-            # Re-raise exceptions from get_database_manager to preserve the specific error
             raise
         except Exception as e:
-            # Attempt to rollback if a session was active
-            db_manager = self._db_connections.get(database)
-            if db_manager:
-                db_manager.get_session().rollback()
+            # Attempt rollback if supported/needed
+            try:
+                provider = self.get_database_provider(company_short_name, database_name)
+                if provider:
+                    provider.rollback()
+            except Exception:
+                pass
 
             error_message = str(e)
             if 'timed out' in str(e):
@@ -122,22 +155,20 @@ class SqlService:
             raise IAToolkitException(IAToolkitException.ErrorType.DATABASE_ERROR,
                                      error_message) from e
 
-    def commit(self, database: str):
+    def commit(self, company_short_name: str, database_name: str):
         """
-        Commits the current transaction for a registered database.
-        Useful when multiple exec_sql calls are part of a single transaction.
+        Commits the current transaction for a registered database provider.
         """
-
-        # Get the database manager from the cache
-        db_manager = self.get_database_manager(database)
+        provider = self.get_database_provider(company_short_name, database_name)
         try:
-            db_manager.get_session().commit()
-        except SQLAlchemyError as db_error:
-            db_manager.get_session().rollback()
-            logging.error(f"Error de base de datos: {str(db_error)}")
-            raise db_error
+            provider.commit()
         except Exception as e:
-            logging.error(f"error while commiting sql: '{str(e)}'")
+            # Try rollback
+            try:
+                provider.rollback()
+            except:
+                pass
+            logging.error(f"Error while committing sql: '{str(e)}'")
             raise IAToolkitException(
                 IAToolkitException.ErrorType.DATABASE_ERROR, str(e)
             )

iatoolkit/services/tool_service.py

@@ -5,6 +5,7 @@
 
 from injector import inject
 from iatoolkit.repositories.llm_query_repo import LLMQueryRepo
+from iatoolkit.repositories.profile_repo import ProfileRepo
 from iatoolkit.repositories.models import Company, Tool
 from iatoolkit.common.exceptions import IAToolkitException
 from iatoolkit.services.sql_service import SqlService
@@ -98,20 +99,20 @@ _SYSTEM_TOOLS = [
     },
     {
         "function_name": "iat_sql_query",
-        "description": "Servicio SQL de IAToolkit: debes utilizar este servicio para todas las consultas a base de datos.",
+        "description": "Servicio SQL de IAToolkit: debes utilizar este servicio para todas las consultas SQL a bases de datos.",
         "parameters": {
             "type": "object",
             "properties": {
-                "database": {
+                "database_key": {
                     "type": "string",
-                    "description": "nombre de la base de datos a consultar: `database_name`"
+                    "description": "IMPORTANT: nombre de la base de datos a consultar."
                 },
                 "query": {
                     "type": "string",
                     "description": "string con la consulta en sql"
                 },
             },
-            "required": ["database", "query"]
+            "required": ["database_key", "query"]
         }
     }
 ]
@@ -121,10 +122,12 @@ class ToolService:
     @inject
     def __init__(self,
                  llm_query_repo: LLMQueryRepo,
+                 profile_repo: ProfileRepo,
                  sql_service: SqlService,
                  excel_service: ExcelService,
                  mail_service: MailService):
         self.llm_query_repo = llm_query_repo
+        self.profile_repo = profile_repo
         self.sql_service = sql_service
         self.excel_service = excel_service
         self.mail_service = mail_service
@@ -158,14 +161,22 @@ class ToolService:
             self.llm_query_repo.rollback()
             raise IAToolkitException(IAToolkitException.ErrorType.DATABASE_ERROR, str(e))
 
-    def sync_company_tools(self, company_instance, tools_config: list):
+    def sync_company_tools(self, company_short_name: str, tools_config: list):
         """
         Synchronizes tools from YAML config to Database (Create/Update/Delete strategy).
         """
+        if not tools_config:
+            return
+
+        company = self.profile_repo.get_company_by_short_name(company_short_name)
+        if not company:
+            raise IAToolkitException(IAToolkitException.ErrorType.INVALID_NAME,
+                                     f'Company {company_short_name} not found')
+
         try:
             # 1. Get existing tools map for later cleanup
             existing_tools = {
-                f.name: f for f in self.llm_query_repo.get_company_tools(company_instance.company)
+                f.name: f for f in self.llm_query_repo.get_company_tools(company)
             }
             defined_tool_names = set()
 
@@ -177,7 +188,7 @@ class ToolService:
                 # Construct the tool object with current config values
                 # We create a new transient object and let the repo merge it
                 tool_obj = Tool(
-                    company_id=company_instance.company.id,
+                    company_id=company.id,
                     name=name,
                     description=tool_data['description'],
                     parameters=tool_data['params'],
@@ -206,11 +217,12 @@ class ToolService:
         Returns the list of tools (System + Company) formatted for the LLM (OpenAI Schema).
         """
         tools = []
-        # Obtiene tanto las de la empresa como las del sistema (la query del repo debería soportar esto con OR)
-        functions = self.llm_query_repo.get_company_tools(company)
 
-        for function in functions:
-            # Clonamos para no modificar el objeto de la sesión SQLAlchemy
+        # get all the tools for the company and system
+        company_tools = self.llm_query_repo.get_company_tools(company)
+
+        for function in company_tools:
+            # clone for no modify the SQLAlchemy session object
             params = function.parameters.copy() if function.parameters else {}
             params["additionalProperties"] = False
 
@@ -221,6 +233,9 @@ class ToolService:
                 "parameters": params,
                 "strict": True
             }
+            if function.name == 'iat_sql_query':
+                params['properties']['database_key']['enum'] = self.sql_service.get_db_names(company.short_name)
+
             tools.append(ai_tool)
         return tools
 

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);