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

iatoolkit/services/prompt_service.py

@@ -9,7 +9,8 @@ from iatoolkit.repositories.llm_query_repo import LLMQueryRepo
 from iatoolkit.services.i18n_service import I18nService
 from iatoolkit.repositories.profile_repo import ProfileRepo
 from collections import defaultdict
-from iatoolkit.repositories.models import Prompt, PromptCategory, Company
+from iatoolkit.repositories.models import (Prompt, PromptCategory,
+                                           Company, PromptType)
 from iatoolkit.common.exceptions import IAToolkitException
 import importlib.resources
 import logging
@@ -34,14 +35,14 @@ class PromptService:
         self.profile_repo = profile_repo
         self.i18n_service = i18n_service
 
-    def sync_company_prompts(self, company_short_name: str, prompts_config: list, categories_config: list):
+    def sync_company_prompts(self, company_short_name: str, prompt_list: list, categories_config: list):
         """
         Synchronizes prompt categories and prompts from YAML config to Database.
         Strategies:
         - Categories: Create or Update existing based on name.
         - Prompts: Create or Update existing based on name. Soft-delete or Delete unused.
         """
-        if not prompts_config:
+        if not prompt_list:
             return
 
         company = self.profile_repo.get_company_by_short_name(company_short_name)
@@ -49,6 +50,7 @@ class PromptService:
             raise IAToolkitException(IAToolkitException.ErrorType.INVALID_NAME,
                                      f'Company {company_short_name} not found')
 
+        self._register_system_prompts(company)
         try:
             # 1. Sync Categories
             category_map = {}
@@ -66,7 +68,7 @@ class PromptService:
             # 2. Sync Prompts
             defined_prompt_names = set()
 
-            for prompt_data in prompts_config:
+            for prompt_data in prompt_list:
                 category_name = prompt_data.get('category')
                 if not category_name or category_name not in category_map:
                     logging.warning(
@@ -86,7 +88,7 @@ class PromptService:
                     order=prompt_data.get('order'),
                     category_id=category_obj.id,
                     active=prompt_data.get('active', True),
-                    is_system_prompt=False,
+                    prompt_type=PromptType.COMPANY.value,
                     filename=filename,
                     custom_fields=prompt_data.get('custom_fields', [])
                 )
@@ -106,7 +108,7 @@ class PromptService:
             self.llm_query_repo.rollback()
             raise IAToolkitException(IAToolkitException.ErrorType.DATABASE_ERROR, str(e))
 
-    def register_system_prompts(self):
+    def _register_system_prompts(self, company: Company):
         """
         Synchronizes system prompts defined in Dispatcher/Code to Database.
         """
@@ -116,20 +118,26 @@ class PromptService:
             for i, prompt_data in enumerate(_SYSTEM_PROMPTS):
                 prompt_name = prompt_data['name']
                 defined_names.add(prompt_name)
+                prompt_filename = f"{prompt_name}.prompt"
 
                 new_prompt = Prompt(
-                    company_id=None,  # System prompts have no company
+                    company_id=company.id,
                     name=prompt_name,
                     description=prompt_data['description'],
                     order=i + 1,
                     category_id=None,
                     active=True,
-                    is_system_prompt=True,
-                    filename=f"{prompt_name}.prompt",
+                    prompt_type=PromptType.SYSTEM.value,
+                    filename=prompt_filename,
                     custom_fields=[]
                 )
                 self.llm_query_repo.create_or_update_prompt(new_prompt)
 
+                # add prompt to company assets
+                if not self.asset_repo.exists(company.short_name, AssetType.PROMPT, prompt_filename):
+                    prompt_content = importlib.resources.read_text('iatoolkit.system_prompts', prompt_filename)
+                    self.asset_repo.write_text(company.short_name, AssetType.PROMPT, prompt_filename, prompt_content)
+
             # Cleanup old system prompts
             existing_sys_prompts = self.llm_query_repo.get_system_prompts()
             for p in existing_sys_prompts:
@@ -149,7 +157,7 @@ class PromptService:
                       company: Company = None,
                       category: PromptCategory = None,
                       active: bool = True,
-                      is_system_prompt: bool = False,
+                      prompt_type: PromptType = PromptType.COMPANY,
                       custom_fields: list = []
                       ):
         """
@@ -157,7 +165,7 @@ class PromptService:
             Validates file existence before creating DB entry.
         """
         prompt_filename = prompt_name.lower() + '.prompt'
-        if is_system_prompt:
+        if prompt_type == PromptType.SYSTEM:
             if not importlib.resources.files('iatoolkit.system_prompts').joinpath(prompt_filename).is_file():
                 raise IAToolkitException(IAToolkitException.ErrorType.INVALID_NAME,
                                 f'missing system prompt file: {prompt_filename}')
@@ -181,10 +189,10 @@ class PromptService:
                 name=prompt_name,
                 description=description,
                 order=order,
-                category_id=category.id if category and not is_system_prompt else None,
+                category_id=category.id if category and prompt_type != PromptType.SYSTEM else None,
                 active=active,
                 filename=prompt_filename,
-                is_system_prompt=is_system_prompt,
+                prompt_type=prompt_type.value,
                 custom_fields=custom_fields
             )
 
@@ -196,21 +204,25 @@ class PromptService:
 
     def get_prompt_content(self, company: Company, prompt_name: str):
         try:
-            # get the user prompt
-            user_prompt = self.llm_query_repo.get_prompt_by_name(company, prompt_name)
-            if not user_prompt:
+            # get the prompt
+            prompt = self.llm_query_repo.get_prompt_by_name(company, prompt_name)
+            if not prompt:
                 raise IAToolkitException(IAToolkitException.ErrorType.DOCUMENT_NOT_FOUND,
-                                   f"prompt not found '{prompt_name}' for company '{company.short_name}'")
+                                   f"prompt not found '{prompt}' for company '{company.short_name}'")
 
             try:
-                user_prompt_content = self.asset_repo.read_text(
-                    company.short_name,
-                    AssetType.PROMPT,
-                    user_prompt.filename
-                )
+                if (prompt.prompt_type == PromptType.SYSTEM.value and
+                        not self.asset_repo.exists(company.short_name, AssetType.PROMPT, prompt.filename)):
+                            user_prompt_content = importlib.resources.read_text('iatoolkit.system_prompts', prompt.filename)
+                else:
+                    user_prompt_content = self.asset_repo.read_text(
+                        company.short_name,
+                        AssetType.PROMPT,
+                        prompt.filename
+                    )
             except FileNotFoundError:
                 raise IAToolkitException(IAToolkitException.ErrorType.FILE_IO_ERROR,
-                                         f"prompt file '{user_prompt.filename}' does not exist for company '{company.short_name}'")
+                                         f"prompt file '{prompt.filename}' does not exist for company '{company.short_name}'")
             except Exception as e:
                 raise IAToolkitException(IAToolkitException.ErrorType.FILE_IO_ERROR,
                                          f"error while reading prompt: '{prompt_name}': {e}")
@@ -225,6 +237,114 @@ class PromptService:
             raise IAToolkitException(IAToolkitException.ErrorType.PROMPT_ERROR,
                                f'error loading prompt "{prompt_name}" content for company {company.short_name}: {str(e)}')
 
+    def save_prompt(self, company_short_name: str, prompt_name: str, data: dict):
+        """
+        Create or Update a prompt.
+        1. Saves the Jinja content to the .prompt file.
+        2. Updates the Metadata (params, description) in company.yaml using ConfigurationService.
+        3. Updates the Database.
+        """
+        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")
+
+        # Validate category if present
+        category_id = None
+        if 'category' in data:
+             # simple lookup, assuming category names are unique per company
+             cat = self.llm_query_repo.get_category_by_name(company.id, data['category'])
+             if cat:
+                 category_id = cat.id
+
+        # 1. save the phisical part of the prompt (content)
+        if 'content' in data:
+            filename = f"{prompt_name}.prompt"
+            filename = filename.lower().replace(' ', '_')
+            self.asset_repo.write_text(company_short_name, AssetType.PROMPT, filename, data['content'])
+
+        # 2. Sync the metadata with company.yaml (lazy import here)
+        # Extract the fields that go to the YAML
+        yaml_metadata = {
+            'name': prompt_name,
+            'description': data.get('description', ''),
+            'category': data.get('category'),
+            'prompt_type': data.get('prompt_type', 'company'),
+            'order': data.get('order', 1),
+            'active': data.get('active', True),
+            'custom_fields': data.get('custom_fields', [])
+        }
+
+        self._sync_to_configuration(company_short_name, yaml_metadata)
+
+        # 3. Reflejar cambios en la BD inmediatamente (para no esperar recarga)
+        # Esto es opcional si confías en que _sync_to_configuration recargará la config,
+        # pero es más seguro actualizar la entidad actual.
+        prompt_db = self.llm_query_repo.get_prompt_by_name(company, prompt_name)
+        if not prompt_db:
+             # Create new prompt in DB immediately for responsiveness
+             new_prompt = Prompt(
+                company_id=company.id,
+                name=prompt_name,
+                description=yaml_metadata['description'],
+                order=yaml_metadata['order'],
+                category_id=category_id,
+                active=yaml_metadata['active'],
+                prompt_type=yaml_metadata['prompt_type'],
+                filename=f"{prompt_name.lower().replace(' ', '_')}.prompt",
+                custom_fields=yaml_metadata['custom_fields']
+            )
+             self.llm_query_repo.create_or_update_prompt(new_prompt)
+        else:
+            prompt_db.description = yaml_metadata['description']
+            prompt_db.category_id = category_id
+            prompt_db.order = yaml_metadata['order']
+            prompt_db.custom_fields = yaml_metadata['custom_fields']
+            prompt_db.active = yaml_metadata['active']
+            self.llm_query_repo.create_or_update_prompt(prompt_db)
+
+    def _sync_to_configuration(self, company_short_name: str, prompt_data: dict):
+        """
+        Usa ConfigurationService para inyectar este prompt en la lista 'prompts.prompt_list' del YAML.
+        """
+        # --- LAZY IMPORT para evitar Circular Dependency ---
+        from iatoolkit import current_iatoolkit
+        from iatoolkit.services.configuration_service import ConfigurationService
+
+        config_service = current_iatoolkit().get_injector().get(ConfigurationService)
+
+        # 1. Obtenemos la configuración actual cruda (sin objetos Python)
+        #    Necesitamos leer la estructura para encontrar si el prompt ya existe en la lista.
+        full_config = config_service._load_and_merge_configs(company_short_name)
+
+        prompts_config = full_config.get('prompts', {})
+        # Normalizar estructura si prompts es una lista o un dict
+        if isinstance(prompts_config, list):
+            # Estructura antigua o simple, la convertimos a dict
+            prompts_config = {'prompt_list': prompts_config, 'prompt_categories': []}
+
+        prompt_list = prompts_config.get('prompt_list', [])
+
+        # 2. Buscar si el prompt ya existe en la lista
+        found_index = -1
+        for i, p in enumerate(prompt_list):
+            if p.get('name') == prompt_data['name']:
+                found_index = i
+                break
+
+        # 3. Construir la ruta de actualización (key path)
+        if found_index >= 0:
+            # Actualizar existente: "prompts.prompt_list.3"
+            # Nota: prompt_data contiene keys como 'description', 'custom_fields', etc.
+            # ConfigurationService.update_configuration_key espera una clave y un valor.
+            # Podríamos actualizar todo el objeto del prompt en la lista.
+            key_path = f"prompts.prompt_list.{found_index}"
+            config_service.update_configuration_key(company_short_name, key_path, prompt_data)
+        else:
+            # Crear nuevo: Agregar a la lista
+            # Usamos el método add_configuration_key que creaste anteriormente
+            config_service.add_configuration_key(company_short_name, "prompts.prompt_list", str(len(prompt_list)), prompt_data)
+
     def get_system_prompt(self):
         try:
             system_prompt_content = []
@@ -253,7 +373,7 @@ class PromptService:
             raise IAToolkitException(IAToolkitException.ErrorType.PROMPT_ERROR,
                                f'error reading the system prompts": {str(e)}')
 
-    def get_user_prompts(self, company_short_name: str) -> dict:
+    def get_user_prompts(self, company_short_name: str, include_all: bool = False) -> dict:
         try:
             # validate company
             company = self.profile_repo.get_company_by_short_name(company_short_name)
@@ -261,15 +381,31 @@ class PromptService:
                 return {"error": self.i18n_service.t('errors.company_not_found', company_short_name=company_short_name)}
 
             # get all the prompts
-            all_prompts = self.llm_query_repo.get_prompts(company)
+            # If include_all is True, repo should return everything for the company
+            all_prompts = self.llm_query_repo.get_prompts(company, include_all=include_all)
+
+            # Deduplicate prompts by id
+            all_prompts = list({p.id: p for p in all_prompts}.values())
 
             # group by category
             prompts_by_category = defaultdict(list)
             for prompt in all_prompts:
-                if prompt.active:
-                    if prompt.category:
-                        cat_key = (prompt.category.order, prompt.category.name)
-                        prompts_by_category[cat_key].append(prompt)
+                # Filter logic moved here or in repo.
+                # If include_all is False, we only want active prompts (and maybe only specific types)
+                if not include_all:
+                    if not prompt.active:
+                        continue
+                    # Standard user view: usually excludes system/agent hidden prompts if any?
+                    # Current requirement: "solo los de tipo company, activos" for end users
+                    if prompt.prompt_type != PromptType.COMPANY.value:
+                        continue
+
+                # Grouping logic
+                cat_key = (0, "Uncategorized") # Default
+                if prompt.category:
+                    cat_key = (prompt.category.order, prompt.category.name)
+
+                prompts_by_category[cat_key].append(prompt)
 
             # sort each category by order
             for cat_key in prompts_by_category:
@@ -288,6 +424,8 @@ class PromptService:
                         {
                             'prompt': p.name,
                             'description': p.description,
+                            'type': p.prompt_type,
+                            'active': p.active,
                             'custom_fields': p.custom_fields,
                             'order': p.order
                         }
@@ -301,3 +439,46 @@ class PromptService:
             logging.error(f"error in get_prompts: {e}")
             return {'error': str(e)}
 
+    def delete_prompt(self, company_short_name: str, prompt_name: str):
+        """
+        Deletes a prompt:
+        1. Removes from DB.
+        2. Removes from YAML config.
+        3. (Optional) Deletes/Archives physical file.
+        """
+        company = self.profile_repo.get_company_by_short_name(company_short_name)
+        if not company:
+            raise IAToolkitException(IAToolkitException.ErrorType.INVALID_NAME, f"Company not found")
+
+        prompt_db = self.llm_query_repo.get_prompt_by_name(company, prompt_name)
+        if not prompt_db:
+            raise IAToolkitException(IAToolkitException.ErrorType.DOCUMENT_NOT_FOUND, f"Prompt {prompt_name} not found")
+
+        # 1. Remove from DB
+        self.llm_query_repo.delete_prompt(prompt_db)
+
+        # 2. Remove from Configuration (Lazy import)
+        from iatoolkit import current_iatoolkit
+        from iatoolkit.services.configuration_service import ConfigurationService
+        config_service = current_iatoolkit().get_injector().get(ConfigurationService)
+
+        # We need to find the index to remove it from the list in YAML
+        full_config = config_service._load_and_merge_configs(company_short_name)
+        prompts_list = full_config.get('prompts', {}).get('prompt_list', [])
+
+        found_index = -1
+        for i, p in enumerate(prompts_list):
+            if p.get('name') == prompt_name:
+                found_index = i
+                break
+
+        if found_index >= 0:
+            # This is tricky with current ConfigService if it doesn't support list item deletion easily.
+            # Assuming we might need to implement a 'delete_configuration_key' or similar,
+            # OR just leave it in config but update DB. For now, let's assume manual config cleanup or
+            # implement a specific removal if ConfigService supports it.
+            # If ConfigService doesn't support removal, we might just mark it inactive in config.
+            pass
+            # config_service.remove_list_item(company_short_name, "prompts.prompt_list", found_index)
+
+

iatoolkit/services/sql_service.py

@@ -171,4 +171,21 @@ class SqlService:
             logging.error(f"Error while committing sql: '{str(e)}'")
             raise IAToolkitException(
                 IAToolkitException.ErrorType.DATABASE_ERROR, str(e)
+            )
+
+    def get_database_structure(self, company_short_name: str, db_name: str) -> dict:
+        """
+        Introspects the specified database and returns its structure (Tables & Columns).
+        Used for the Schema Editor 2.0
+        """
+        try:
+            provider = self.get_database_provider(company_short_name, db_name)
+            return provider.get_database_structure()
+        except IAToolkitException:
+            raise
+        except Exception as e:
+            logging.error(f"Error introspecting database '{db_name}': {e}")
+            raise IAToolkitException(
+                IAToolkitException.ErrorType.DATABASE_ERROR,
+                f"Failed to introspect database: {str(e)}"
             )

iatoolkit/templates/chat.html

@@ -8,6 +8,7 @@
     {# Movemos los estilos y los links aquí para que se rendericen en el <head> #}
     <style>
         {{ branding.css_variables | safe }}
+        {{ branding.css_variables | safe }}
     </style>
     <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/5.15.4/css/all.min.css">
     <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap-icons@1.11.3/font/bootstrap-icons.min.css">
@@ -104,7 +105,7 @@
                        style="color: {{ branding.header_text_color }};">
                         <i class="bi bi-question-circle-fill"></i>
                 </a>
-                {% if user_role == "admin" and license == 'enterprise' %}
+                {% if user_role != "user" and license == 'enterprise' %}
                     <a href="/{{ company_short_name }}/admin/dashboard"
                        target="_blank"
                            id="preferences-button"

iatoolkit/views/categories_api_view.py

@@ -0,0 +1,71 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+from flask import jsonify
+from flask.views import MethodView
+from injector import inject
+from iatoolkit.services.auth_service import AuthService
+from iatoolkit.services.profile_service import ProfileService
+from iatoolkit.services.configuration_service import ConfigurationService
+from iatoolkit.services.knowledge_base_service import KnowledgeBaseService
+from iatoolkit.repositories.llm_query_repo import LLMQueryRepo
+from iatoolkit.repositories.models import PromptType, PromptCategory
+import logging
+
+class CategoriesApiView(MethodView):
+    """
+    Endpoint to retrieve all available categories and types in the system.
+    Useful for populating dropdowns in the frontend.
+    """
+    @inject
+    def __init__(self,
+                 auth_service: AuthService,
+                 profile_service: ProfileService,
+                 configuration_service: ConfigurationService,
+                 knowledge_base_service: KnowledgeBaseService,
+                 llm_query_repo: LLMQueryRepo):
+        self.auth_service = auth_service
+        self.profile_service = profile_service
+        self.knowledge_base_service = knowledge_base_service
+        self.llm_query_repo = llm_query_repo
+        self.configuration_service = configuration_service
+
+    def get(self, company_short_name):
+        try:
+            # 1. Verify Authentication
+            auth_result = self.auth_service.verify()
+            if not auth_result.get("success"):
+                return jsonify(auth_result), 401
+
+            # 2. Get Company
+            company = self.profile_service.get_company_by_short_name(company_short_name)
+            if not company:
+                return jsonify({"error": "Company not found"}), 404
+
+            # 3. Gather Categories
+            response_data = {
+                "prompt_types": [t.value for t in PromptType],
+                "prompt_categories": [],
+                "collection_types": [],
+                # Future categories can be added here (e.g., tool_types, user_roles)
+            }
+
+            # A. Prompt Categories (from DB)
+            prompt_cats = self.llm_query_repo.get_all_categories(company_id=company.id)
+            response_data["prompt_categories"] = [c.name for c in prompt_cats]
+
+            # B. Collection Types (from KnowledgeBaseService)
+            response_data["collection_types"] = self.knowledge_base_service.get_collection_names(company_short_name)
+
+            # C. LLM Models (from ConfigurationService)
+            _, llm_models = self.configuration_service.get_llm_configuration(company_short_name)
+            # Extract only IDs
+            response_data["llm_models"] = [m['id'] for m in llm_models if 'id' in m]
+
+            return jsonify(response_data)
+
+        except Exception as e:
+            logging.exception(f"Error fetching categories for {company_short_name}: {e}")
+            return jsonify({"status": "error", "message": str(e)}), 500

iatoolkit/views/configuration_api_view.py

@@ -0,0 +1,163 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+from flask import jsonify, request
+from flask.views import MethodView
+from injector import inject
+from iatoolkit.services.configuration_service import ConfigurationService
+from iatoolkit.services.profile_service import ProfileService
+from iatoolkit.services.auth_service import AuthService
+import logging
+
+
+class ConfigurationApiView(MethodView):
+    """
+    API View to manage company configuration.
+    Supports loading, updating specific keys, and validating the configuration.
+    """
+    @inject
+    def __init__(self,
+                 configuration_service: ConfigurationService,
+                 profile_service: ProfileService,
+                 auth_service: AuthService):
+        self.configuration_service = configuration_service
+        self.profile_service = profile_service
+        self.auth_service = auth_service
+
+    def get(self, company_short_name: str = None):
+        """
+        Loads the current configuration for the company.
+        """
+        try:
+            # 1. Verify authentication
+            auth_result = self.auth_service.verify(anonymous=True)
+            if not auth_result.get("success"):
+                return jsonify(auth_result), auth_result.get("status_code", 401)
+
+            company = self.profile_service.get_company_by_short_name(company_short_name)
+            if not company:
+                return jsonify({"error": "company not found."}), 404
+
+            config, errors = self.configuration_service.load_configuration(company_short_name)
+
+            # Register data sources to ensure services are up to date with loaded config
+            if config:
+                self.configuration_service.register_data_sources(company_short_name)
+
+            # Remove non-serializable objects
+            if 'company' in config:
+                config.pop('company')
+
+            status_code = 200 if not errors else 400
+            return jsonify({'config': config, 'errors': errors}), status_code
+        except Exception as e:
+            logging.exception(f"Unexpected error loading config: {e}")
+            return jsonify({'status': 'error', 'message': str(e)}), 500
+
+    def patch(self, company_short_name: str):
+        """
+        Updates a specific configuration key.
+        Body: { "key": "llm.model", "value": "gpt-4" }
+        """
+        try:
+            auth_result = self.auth_service.verify()
+            if not auth_result.get("success"):
+                return jsonify(auth_result), 401
+
+            payload = request.get_json()
+            key = payload.get('key')
+            value = payload.get('value')
+
+            if not key:
+                return jsonify({'error': 'Missing "key" in payload'}), 400
+
+            logging.info(f"Updating config key '{key}' for company '{company_short_name}'")
+
+            updated_config, errors = self.configuration_service.update_configuration_key(
+                company_short_name, key, value
+            )
+
+            # Remove non-serializable objects
+            if 'company' in updated_config:
+                updated_config.pop('company')
+
+            if errors:
+                return jsonify({'status': 'invalid', 'errors': errors, 'config': updated_config}), 400
+
+            return jsonify({'status': 'success', 'config': updated_config}), 200
+
+        except FileNotFoundError:
+            return jsonify({'error': 'Configuration file not found'}), 404
+        except Exception as e:
+            logging.exception(f"Error updating config: {e}")
+            return jsonify({'status': 'error', 'message': str(e)}), 500
+
+    def post(self, company_short_name: str):
+        """
+        Adds a new configuration key.
+        Body: { "parent_key": "llm", "key": "max_tokens", "value": 2048 }
+        """
+        try:
+            auth_result = self.auth_service.verify(anonymous=False)
+            if not auth_result.get("success"):
+                return jsonify(auth_result), 401
+
+            payload = request.get_json()
+            parent_key = payload.get('parent_key', '')  # Optional, defaults to root
+            key = payload.get('key')
+            value = payload.get('value')
+
+            if not key:
+                return jsonify({'error': 'Missing "key" in payload'}), 400
+
+            logging.info(f"Adding config key '{key}' under '{parent_key}' for company '{company_short_name}'")
+
+            updated_config, errors = self.configuration_service.add_configuration_key(
+                company_short_name, parent_key, key, value
+            )
+
+            # Remove non-serializable objects
+            if 'company' in updated_config:
+                updated_config.pop('company')
+
+            if errors:
+                return jsonify({'status': 'invalid', 'errors': errors, 'config': updated_config}), 400
+
+            return jsonify({'status': 'success', 'config': updated_config}), 200
+
+        except FileNotFoundError:
+            return jsonify({'error': 'Configuration file not found'}), 404
+        except Exception as e:
+            logging.exception(f"Error adding config key: {e}")
+            return jsonify({'status': 'error', 'message': str(e)}), 500
+
+class ValidateConfigurationApiView(MethodView):
+    """
+    API View to trigger an explicit validation of the current configuration.
+    Useful for UI to check status without modifying data.
+    """
+    @inject
+    def __init__(self,
+                 configuration_service: ConfigurationService,
+                 auth_service: AuthService):
+        self.configuration_service = configuration_service
+        self.auth_service = auth_service
+
+    def get(self, company_short_name: str):
+        try:
+            auth_result = self.auth_service.verify(anonymous=False)
+            if not auth_result.get("success"):
+                return jsonify(auth_result), 401
+
+            errors = self.configuration_service.validate_configuration(company_short_name)
+
+            if errors:
+                return jsonify({'status': 'invalid', 'errors': errors}), 200  # 200 OK because check succeeded
+
+            return jsonify({'status': 'valid', 'errors': []}), 200
+
+        except Exception as e:
+            logging.exception(f"Error validating config: {e}")
+            return jsonify({'status': 'error', 'message': str(e)}), 500