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

iatoolkit/services/query_service.py

@@ -8,6 +8,9 @@ from iatoolkit.services.profile_service import ProfileService
 from iatoolkit.repositories.document_repo import DocumentRepo
 from iatoolkit.repositories.profile_repo import ProfileRepo
 from iatoolkit.services.document_service import DocumentService
+from iatoolkit.services.company_context_service import CompanyContextService
+from iatoolkit.services.i18n_service import I18nService
+from iatoolkit.services.configuration_service import ConfigurationService
 from iatoolkit.repositories.llm_query_repo import LLMQueryRepo
 from iatoolkit.repositories.models import Task
 from iatoolkit.services.dispatcher_service import Dispatcher
@@ -32,31 +35,60 @@ class QueryService:
     def __init__(self,
                  llm_client: llmClient,
                  profile_service: ProfileService,
+                 company_context_service: CompanyContextService,
                  document_service: DocumentService,
                  document_repo: DocumentRepo,
                  llmquery_repo: LLMQueryRepo,
                  profile_repo: ProfileRepo,
                  prompt_service: PromptService,
+                 i18n_service: I18nService,
                  util: Utility,
                  dispatcher: Dispatcher,
-                 session_context: UserSessionContextService
+                 session_context: UserSessionContextService,
+                 configuration_service: ConfigurationService
                  ):
         self.profile_service = profile_service
+        self.company_context_service = company_context_service
         self.document_service = document_service
         self.document_repo = document_repo
         self.llmquery_repo = llmquery_repo
         self.profile_repo = profile_repo
         self.prompt_service = prompt_service
+        self.i18n_service = i18n_service
         self.util = util
         self.dispatcher = dispatcher
         self.session_context = session_context
+        self.configuration_service = configuration_service
         self.llm_client = llm_client
 
         # get the model from the environment variable
-        self.model = os.getenv("LLM_MODEL", "")
-        if not self.model:
+        self.default_model = os.getenv("LLM_MODEL", "")
+        if not self.default_model:
             raise IAToolkitException(IAToolkitException.ErrorType.API_KEY,
-                               "La variable de entorno 'LLM_MODEL' no está configurada.")
+                               "missing ENV variable 'LLM_MODEL' configuration.")
+
+    def init_context(self, company_short_name: str,
+                     user_identifier: str,
+                     model: str = None) -> dict:
+
+        # 1. Execute the forced rebuild sequence using the unified identifier.
+        self.session_context.clear_all_context(company_short_name, user_identifier)
+        logging.info(f"Context for {company_short_name}/{user_identifier} has been cleared.")
+
+        # 2. LLM context is clean, now we can load it again
+        self.prepare_context(
+            company_short_name=company_short_name,
+            user_identifier=user_identifier
+        )
+
+        # 3. communicate the new context to the LLM
+        response = self.set_context_for_llm(
+            company_short_name=company_short_name,
+            user_identifier=user_identifier,
+            model=model
+        )
+
+        return response
 
     def _build_context_and_profile(self, company_short_name: str, user_identifier: str) -> tuple:
         # this method read the user/company context from the database and renders the system prompt
@@ -78,7 +110,7 @@ class QueryService:
         )
 
         # get the company context: schemas, database models, .md files
-        company_specific_context = self.dispatcher.get_company_context(company_name=company_short_name)
+        company_specific_context = self.company_context_service.get_company_context(company_short_name)
 
         # merge context: company + user
         final_system_context = f"{company_specific_context}\n{rendered_system_prompt}"
@@ -112,22 +144,39 @@ class QueryService:
 
         if rebuild_is_needed:
             # Guardar el contexto preparado y su versión para que `finalize_context_rebuild` los use.
-            self.session_context.save_prepared_context(company_short_name, user_identifier, final_system_context,
+            self.session_context.save_prepared_context(company_short_name,
+                                                       user_identifier,
+                                                       final_system_context,
                                                        current_version)
 
         return {'rebuild_needed': rebuild_is_needed}
 
-    def finalize_context_rebuild(self, company_short_name: str, user_identifier: str, model: str = ''):
+    def set_context_for_llm(self,
+                            company_short_name: str,
+                            user_identifier: str,
+                            model: str = ''):
 
-        # end the initilization, if there is a prepare context send it to llm
-        if not model:
-            model = self.model
+        # This service takes a pre-built context and send to the LLM
+        company = self.profile_repo.get_company_by_short_name(company_short_name)
+        if not company:
+            logging.error(f"Company not found: {company_short_name} in set_context_for_llm")
+            return
+
+        # --- Model Resolution ---
+        # Priority: 1. Explicit model -> 2. Company config -> 3. Global default
+        effective_model = model
+        if not effective_model:
+            llm_config = self.configuration_service.get_configuration(company_short_name, 'llm')
+            if llm_config and llm_config.get('model'):
+                effective_model = llm_config['model']
 
-        # --- Lógica de Bloqueo ---
+        effective_model = effective_model or self.default_model
+
+        # blocking logic to avoid multiple requests for the same user/company at the same time
         lock_key = f"lock:context:{company_short_name}/{user_identifier}"
         if not self.session_context.acquire_lock(lock_key, expire_seconds=60):
             logging.warning(
-                f"Intento de reconstruir contexto para {user_identifier} mientras ya estaba en progreso. Se omite.")
+                f"try to rebuild context for user {user_identifier} while is still in process, ignored.")
             return
 
         try:
@@ -138,22 +187,23 @@ class QueryService:
             prepared_context, version_to_save = self.session_context.get_and_clear_prepared_context(company_short_name,
                                                                                                     user_identifier)
             if not prepared_context:
-                logging.info(
-                    f"No se requiere reconstrucción de contexto para {company_short_name}/{user_identifier}. Finalización rápida.")
                 return
 
-            logging.info(f"Enviando contexto al LLM para {company_short_name}/{user_identifier}...")
+            logging.info(f"sending context to LLM model {effective_model} for: {company_short_name}/{user_identifier}...")
 
-            # Limpiar solo el historial de chat y el ID de respuesta anterior
+            # clean only the chat history and the last response ID for this user/company
             self.session_context.clear_llm_history(company_short_name, user_identifier)
 
-            if self.util.is_gemini_model(model):
+            response_id = ''
+            if self.util.is_gemini_model(effective_model):
                 context_history = [{"role": "user", "content": prepared_context}]
                 self.session_context.save_context_history(company_short_name, user_identifier, context_history)
-
-            elif self.util.is_openai_model(model):
+            elif self.util.is_openai_model(effective_model):
+                # Here is the call to the LLM client for settling the company/user context
                 response_id = self.llm_client.set_company_context(
-                    company=company, company_base_context=prepared_context, model=model
+                    company=company,
+                    company_base_context=prepared_context,
+                    model=effective_model
                 )
                 self.session_context.save_last_response_id(company_short_name, user_identifier, response_id)
 
@@ -161,14 +211,16 @@ class QueryService:
                 self.session_context.save_context_version(company_short_name, user_identifier, version_to_save)
 
             logging.info(
-                f"Contexto de {company_short_name}/{user_identifier} establecido en {int(time.time() - start_time)} seg.")
+                f"Context for: {company_short_name}/{user_identifier} settled in {int(time.time() - start_time)} sec.")
         except Exception as e:
-            logging.exception(f"Error en finalize_context_rebuild para {company_short_name}: {e}")
+            logging.exception(f"Error in finalize_context_rebuild for {company_short_name}: {e}")
             raise e
         finally:
-            # --- Liberar el Bloqueo ---
+            # release the lock
             self.session_context.release_lock(lock_key)
 
+        return {'response_id': response_id }
+
     def llm_query(self,
                   company_short_name: str,
                   user_identifier: str,
@@ -176,29 +228,45 @@ class QueryService:
                   prompt_name: str = None,
                   question: str = '',
                   client_data: dict = {},
-                  files: list = []) -> dict:
+                  response_id: str = '',
+                  files: list = [],
+                  model: Optional[str] = None) -> dict:
         try:
             company = self.profile_repo.get_company_by_short_name(short_name=company_short_name)
             if not company:
                 return {"error": True,
-                        "error_message": f'No existe Company ID: {company_short_name}'}
+                        "error_message": self.i18n_service.t('errors.company_not_found', company_short_name=company_short_name)}
 
             if not prompt_name and not question:
                 return {"error": True,
-                        "error_message": f'Hola, cual es tu pregunta?'}
+                        "error_message": self.i18n_service.t('services.start_query')}
+
+            # --- Model Resolution ---
+            # Priority: 1. Explicit model -> 2. Company config -> 3. Global default
+            effective_model = model
+            if not effective_model:
+                llm_config = self.configuration_service.get_configuration(company_short_name, 'llm')
+                if llm_config and llm_config.get('model'):
+                    effective_model = llm_config['model']
+
+            effective_model = effective_model or self.default_model
 
             # get the previous response_id and context history
             previous_response_id = None
             context_history = self.session_context.get_context_history(company.short_name, user_identifier) or []
 
-            if self.util.is_openai_model(self.model):
-                # get user context
-                previous_response_id = self.session_context.get_last_response_id(company.short_name, user_identifier)
-                if not previous_response_id:
-                    return {'error': True,
-                            "error_message": f"No se encontró 'previous_response_id' para '{company.short_name}/{user_identifier}'. Reinicia el contexto para continuar."
-                            }
-            elif self.util.is_gemini_model(self.model):
+            if self.util.is_openai_model(effective_model):
+                if response_id:
+                    # context is getting from this response_id
+                    previous_response_id = response_id
+                else:
+                    # use the full user history context
+                    previous_response_id = self.session_context.get_last_response_id(company.short_name, user_identifier)
+                    if not previous_response_id:
+                        return {'error': True,
+                                "error_message": self.i18n_service.t('errors.services.missing_response_id', company_short_name=company.short_name, user_identifier=user_identifier)
+                                }
+            elif self.util.is_gemini_model(effective_model):
                 # check the length of the context_history and remove old messages
                 self._trim_context_history(context_history)
 
@@ -237,7 +305,7 @@ class QueryService:
                 user_turn_prompt += f'\n### Contexto Adicional: El usuario ha aportado este contexto puede ayudar: {question}'
 
             # add to the history context
-            if self.util.is_gemini_model(self.model):
+            if self.util.is_gemini_model(effective_model):
                 context_history.append({"role": "user", "content": user_turn_prompt})
 
             # service list for the function calls
@@ -250,8 +318,9 @@ class QueryService:
             response = self.llm_client.invoke(
                 company=company,
                 user_identifier=user_identifier,
+                model=effective_model,
                 previous_response_id=previous_response_id,
-                context_history=context_history if self.util.is_gemini_model(self.model) else None,
+                context_history=context_history if self.util.is_gemini_model(effective_model) else None,
                 question=question,
                 context=user_turn_prompt,
                 tools=tools,
@@ -264,7 +333,7 @@ class QueryService:
             # save last_response_id for the history chain
             if "response_id" in response:
                 self.session_context.save_last_response_id(company.short_name, user_identifier, response["response_id"])
-            if self.util.is_gemini_model(self.model):
+            if self.util.is_gemini_model(effective_model):
                 self.session_context.save_context_history(company.short_name, user_identifier, context_history)
 
             return response
@@ -286,15 +355,15 @@ class QueryService:
         - Gemini: context_history con al menos 1 mensaje.
         """
         try:
-            if self.util.is_openai_model(self.model):
+            if self.util.is_openai_model(self.default_model):
                 prev_id = self.session_context.get_last_response_id(company_short_name, user_identifier)
                 return bool(prev_id)
-            if self.util.is_gemini_model(self.model):
+            if self.util.is_gemini_model(self.default_model):
                 history = self.session_context.get_context_history(company_short_name, user_identifier) or []
                 return len(history) >= 1
             return False
         except Exception as e:
-            logging.warning(f"Error verificando caché de contexto: {e}")
+            logging.warning(f"error verifying context cache: {e}")
             return False
 
     def load_files_for_context(self, files: list) -> str:
@@ -353,7 +422,7 @@ class QueryService:
         try:
             total_tokens = sum(self.llm_client.count_tokens(json.dumps(message)) for message in context_history)
         except Exception as e:
-            logging.error(f"Error al calcular tokens del historial: {e}. No se pudo recortar el contexto.")
+            logging.error(f"error counting tokens for history: {e}.")
             return
 
         # Si se excede el límite, eliminar mensajes antiguos (empezando por el segundo)
@@ -364,8 +433,8 @@ class QueryService:
                 removed_tokens = self.llm_client.count_tokens(json.dumps(removed_message))
                 total_tokens -= removed_tokens
                 logging.warning(
-                    f"Historial de contexto ({total_tokens + removed_tokens} tokens) excedía el límite de {GEMINI_MAX_TOKENS_CONTEXT_HISTORY}. "
-                    f"Nuevo total: {total_tokens} tokens."
+                    f"history tokens ({total_tokens + removed_tokens} tokens) exceed the limit of: {GEMINI_MAX_TOKENS_CONTEXT_HISTORY}. "
+                    f"new context: {total_tokens} tokens."
                 )
             except IndexError:
                 # Se produce si solo queda el mensaje del sistema, el bucle debería detenerse.

iatoolkit/services/search_service.py

@@ -5,19 +5,22 @@
 
 from iatoolkit.repositories.vs_repo import VSRepo
 from iatoolkit.repositories.document_repo import DocumentRepo
+from iatoolkit.repositories.profile_repo import ProfileRepo
+from iatoolkit.repositories.models import Company
 from injector import inject
 
 
 class SearchService:
     @inject
     def __init__(self,
+                 profile_repo: ProfileRepo,
                  doc_repo: DocumentRepo,
                  vs_repo: VSRepo):
-        super().__init__()
+        self.profile_repo = profile_repo
         self.vs_repo = vs_repo
         self.doc_repo = doc_repo
 
-    def search(self, company_id:  int, query: str, metadata_filter: dict = None) -> str:
+    def search(self, company_short_name: str, query: str, metadata_filter: dict = None) -> str:
         """
         Performs a semantic search for a given query within a company's documents.
 
@@ -26,7 +29,7 @@ class SearchService:
         content of the retrieved documents, which can be used as context for an LLM.
 
         Args:
-            company_id: The ID of the company to search within.
+            company_short_name: The  company to search within.
             query: The text query to search for.
             metadata_filter: An optional dictionary to filter documents by their metadata.
 
@@ -34,7 +37,11 @@ class SearchService:
             A string containing the concatenated content of the found documents,
             formatted to be used as a context.
         """
-        document_list = self.vs_repo.query(company_id=company_id,
+        company = self.profile_repo.get_company_by_short_name(company_short_name)
+        if not company:
+            return f"error: company {company_short_name} not found"
+
+        document_list = self.vs_repo.query(company_short_name=company_short_name,
                                            query_text=query,
                                            metadata_filter=metadata_filter)
 

iatoolkit/services/sql_service.py

@@ -4,57 +4,89 @@
 # IAToolkit is open source software.
 
 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 injector import inject
+from injector import inject, singleton
 import json
-from iatoolkit.common.exceptions import IAToolkitException
+import logging
 
 
+@singleton
 class SqlService:
+    """
+    Manages database connections and executes SQL statements.
+    It maintains a cache of named DatabaseManager instances to avoid reconnecting.
+    """
+
     @inject
-    def __init__(self,util: Utility):
+    def __init__(self,
+                 util: Utility,
+                 i18n_service: I18nService):
         self.util = util
+        self.i18n_service = i18n_service
+
+        # Cache for database connections
+        self._db_connections: dict[str, DatabaseManager] = {}
 
-    def exec_sql(self, db_manager: DatabaseManager, sql_statement: str) -> str:
+    def register_database(self, db_name: str, db_uri: str):
+        """
+        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.
         """
-        Executes a raw SQL statement and returns the result as a JSON string.
+        if db_name in self._db_connections:
+            return
 
-        This method takes a DatabaseManager instance and a SQL query, executes it
-        against the database, and fetches all results. The results are converted
-        into a list of dictionaries, where each dictionary represents a row.
-        This list is then serialized to a JSON string.
-        If an exception occurs during execution, the transaction is rolled back,
-        and a custom IAToolkitException is raised.
+        logging.debug(f"Registering and creating connection for database: '{db_name}'")
 
-        Args:
-            db_manager: The DatabaseManager instance to get the database session from.
-            sql_statement: The raw SQL statement to be executed.
+        # create the database connection and save it on the cache
+        db_manager = DatabaseManager(db_uri, register_pgvector=False)
+        self._db_connections[db_name] = db_manager
 
-        Returns:
-            A JSON string representing the list of rows returned by the query.
+    def get_database_manager(self, db_name: str) -> DatabaseManager:
+        """
+        Retrieves a registered DatabaseManager instance from the cache.
         """
         try:
-            # here the SQL is executed
-            result = db_manager.get_session().execute(text(sql_statement))
+            return self._db_connections[db_name]
+        except KeyError:
+            logging.error(f"Attempted to access unregistered database: '{db_name}'")
+            raise IAToolkitException(
+                IAToolkitException.ErrorType.DATABASE_ERROR,
+                f"Database '{db_name}' is not registered with the SqlService."
+            )
 
-            # get the column names
-            cols = result.keys()
+    def exec_sql(self, database: str, query: str) -> str:
+        """
+        Executes a raw SQL statement against a registered database and returns the result as a JSON string.
+        """
+        try:
+            # 1. Get the database manager from the cache
+            db_manager = self.get_database_manager(database)
 
-            # convert rows to dict
+            # 2. Execute the SQL statement
+            result = db_manager.get_session().execute(text(query))
+            cols = result.keys()
             rows_context = [dict(zip(cols, row)) for row in result.fetchall()]
 
-            # Serialize to JSON with type convertion
+            # seialize the result
             sql_result_json = json.dumps(rows_context, default=self.util.serialize)
 
             return sql_result_json
+        except IAToolkitException:
+            # Re-raise exceptions from get_database_manager to preserve the specific error
+            raise
         except Exception as e:
-            db_manager.get_session().rollback()
+            # Attempt to rollback if a session was active
+            db_manager = self._db_connections.get(database)
+            if db_manager:
+                db_manager.get_session().rollback()
 
             error_message = str(e)
             if 'timed out' in str(e):
-                error_message = 'Intentalo de nuevo, se agoto el tiempo de espera'
+                error_message = self.i18n_service.t('errors.timeout')
 
+            logging.error(f"Error executing SQL statement: {error_message}")
             raise IAToolkitException(IAToolkitException.ErrorType.DATABASE_ERROR,
                                      error_message) from e

iatoolkit/services/user_feedback_service.py

@@ -6,8 +6,9 @@
 from iatoolkit.repositories.models import UserFeedback, Company
 from injector import inject
 from iatoolkit.repositories.profile_repo import ProfileRepo
+from iatoolkit.services.i18n_service import I18nService
 from iatoolkit.infra.google_chat_app import GoogleChatApp
-from iatoolkit.infra.mail_app import MailApp  # <-- 1. Importar MailApp
+from iatoolkit.infra.mail_app import MailApp
 import logging
 
 
@@ -15,9 +16,11 @@ class UserFeedbackService:
     @inject
     def __init__(self,
                  profile_repo: ProfileRepo,
+                 i18n_service: I18nService,
                  google_chat_app: GoogleChatApp,
                  mail_app: MailApp):
         self.profile_repo = profile_repo
+        self.i18n_service = i18n_service
         self.google_chat_app = google_chat_app
         self.mail_app = mail_app
 
@@ -31,9 +34,9 @@ class UserFeedbackService:
             }
             chat_result = self.google_chat_app.send_message(message_data=chat_data)
             if not chat_result.get('success'):
-                logging.warning(f"Error al enviar notificación a Google Chat: {chat_result.get('message')}")
+                logging.warning(f"error sending notification to Google Chat: {chat_result.get('message')}")
         except Exception as e:
-            logging.exception(f"Fallo inesperado al enviar notificación a Google Chat: {e}")
+            logging.exception(f"error sending notification to Google Chat: {e}")
 
     def _send_email_notification(self, destination_email: str, company_name: str, message_text: str):
         """Envía una notificación de feedback por correo electrónico."""
@@ -43,20 +46,20 @@ class UserFeedbackService:
             html_body = message_text.replace('\n', '<br>')
             self.mail_app.send_email(to=destination_email, subject=subject, body=html_body)
         except Exception as e:
-            logging.exception(f"Fallo inesperado al enviar email de feedback: {e}")
+            logging.exception(f"error sending email de feedback: {e}")
 
     def _handle_notification(self, company: Company, message_text: str):
         """Lee la configuración de la empresa y envía la notificación al canal correspondiente."""
         feedback_params = company.parameters.get('user_feedback')
         if not isinstance(feedback_params, dict):
-            logging.warning(f"No se encontró configuración de 'user_feedback' para la empresa {company.short_name}.")
+            logging.warning(f"missing 'user_feedback' configuration for company: {company.short_name}.")
             return
 
         # get channel and destination
         channel = feedback_params.get('channel')
         destination = feedback_params.get('destination')
         if not channel or not destination:
-            logging.warning(f"Configuración 'user_feedback' incompleta para {company.short_name}. Faltan 'channel' o 'destination'.")
+            logging.warning(f"invalid 'user_feedback' configuration for: {company.short_name}. Faltan 'channel' o 'destination'.")
             return
 
         if channel == 'google_chat':
@@ -64,7 +67,7 @@ class UserFeedbackService:
         elif channel == 'email':
             self._send_email_notification(destination_email=destination, company_name=company.short_name, message_text=message_text)
         else:
-            logging.warning(f"Canal de feedback '{channel}' no reconocido para la empresa {company.short_name}.")
+            logging.warning(f"unknown feedback channel: '{channel}' for company {company.short_name}.")
 
     def new_feedback(self,
                      company_short_name: str,
@@ -72,19 +75,18 @@ class UserFeedbackService:
                      user_identifier: str,
                      rating: int = None) -> dict:
         try:
-            # 1. Validar empresa
             company = self.profile_repo.get_company_by_short_name(company_short_name)
             if not company:
-                return {'error': f'No existe la empresa: {company_short_name}'}
+                return {'error': self.i18n_service.t('errors.company_not_found', company_short_name=company_short_name)}
 
-            # 2. Enviar notificación según la configuración de la empresa
+            # 2. send notification using company configuration
             notification_text = (f"*Nuevo feedback de {company_short_name}*:\n"
                                  f"*Usuario:* {user_identifier}\n"
                                  f"*Mensaje:* {message}\n"
                                  f"*Calificación:* {rating if rating is not None else 'N/A'}")
             self._handle_notification(company, notification_text)
 
-            # 3. Guardar el feedback en la base de datos (independientemente del éxito de la notificación)
+            # 3. always save the feedback in the database
             new_feedback_obj = UserFeedback(
                 company_id=company.id,
                 message=message,
@@ -93,8 +95,8 @@ class UserFeedbackService:
             )
             saved_feedback = self.profile_repo.save_feedback(new_feedback_obj)
             if not saved_feedback:
-                logging.error(f"No se pudo guardar el feedback para el usuario {user_identifier} en la empresa {company_short_name}")
-                return {'error': 'No se pudo guardar el feedback'}
+                logging.error(f"can't save feedback for user {user_identifier}/{company_short_name}")
+                return {'error': 'can not save the feedback'}
 
             return {'success': True, 'message': 'Feedback guardado correctamente'}
 

iatoolkit/static/js/chat_history_button.js

@@ -25,8 +25,8 @@ $(document).ready(function () {
         const data = await callToolkit("/api/history", {}, "POST");
 
         if (!data || !data.history) {
+            historyLoading.hide();
             toastr.error(t_js('error_loading_history'));
-            historyModal.modal('hide');
             return;
         }
 
@@ -60,7 +60,7 @@ $(document).ready(function () {
         filteredHistory.forEach((item, index) => {
             const icon = $('<i>').addClass('bi bi-pencil-fill');
 
-            const link = $('<a>')
+            const edit_link = $('<a>')
                 .attr('href', 'javascript:void(0);')
                 .addClass('edit-pencil')
                 .attr('title', t_js('edit_query'))
@@ -70,16 +70,14 @@ $(document).ready(function () {
             const row = $('<tr>').append(
                 $('<td>').addClass('text-nowrap').text(formatDate(item.created_at)),
                 $('<td>').text(item.query),
-                $('<td>').append(link),
+                $('<td>').append(edit_link),
             );
-
             historyTableBody.append(row);
         });
     }
 
     function formatDate(dateString) {
         const date = new Date(dateString);
-
         const padTo2Digits = (num) => num.toString().padStart(2, '0');
 
         const day = padTo2Digits(date.getDate());

iatoolkit/static/js/chat_main.js

@@ -229,9 +229,7 @@ const callToolkit = async function(apiPath, data, method, timeoutMs = 500000) {
 
         }
         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.
@@ -244,9 +242,7 @@ const callToolkit = async function(apiPath, data, method, timeoutMs = 500000) {
                 // 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);
+                toastr.error(errorMessage);
             }
             return null;
         }
@@ -256,18 +252,7 @@ const callToolkit = async function(apiPath, data, method, timeoutMs = 500000) {
         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);
+            toastr.error(t_js('network_error') );
         }
         return null;
     }