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

iatoolkit/repositories/models.py

@@ -27,8 +27,6 @@ user_company = Table('iat_user_company',
                      Column('company_id', Integer,
                             ForeignKey('iat_companies.id',ondelete='CASCADE'),
                                 primary_key=True),
-                     Column('is_active', Boolean, default=True),
-                     Column('role', String(50), default='user'),  # Para manejar roles por empresa
                      Column('created_at', DateTime, default=datetime.now)
                      )
 
@@ -36,7 +34,7 @@ class ApiKey(Base):
     """Represents an API key for a company to authenticate against the system."""
     __tablename__ = 'iat_api_keys'
 
-    id = Column(Integer, primary_key=True)
+    id = Column(Integer, primary_key=True, autoincrement=True)
     company_id = Column(Integer, ForeignKey('iat_companies.id', ondelete='CASCADE'), nullable=False)
     key = Column(String(128), unique=True, nullable=False, index=True) # La API Key en sí
     is_active = Column(Boolean, default=True, nullable=False)
@@ -50,7 +48,7 @@ class Company(Base):
     """Represents a company or tenant in the multi-tenant system."""
     __tablename__ = 'iat_companies'
 
-    id = Column(Integer, primary_key=True)
+    id = Column(Integer, primary_key=True, autoincrement=True)
     short_name = Column(String(20), nullable=False, unique=True, index=True)
     name = Column(String(256), nullable=False)
 
@@ -64,7 +62,7 @@ class Company(Base):
                              back_populates="company",
                              cascade="all, delete-orphan",
                              lazy='dynamic')
-    functions = relationship("Function",
+    tools = relationship("Tool",
                            back_populates="company",
                            cascade="all, delete-orphan")
     vsdocs = relationship("VSDoc",
@@ -96,7 +94,7 @@ class User(Base):
     """Represents an IAToolkit user who can be associated with multiple companies."""
     __tablename__ = 'iat_users'
 
-    id = Column(Integer, primary_key=True)
+    id = Column(Integer, primary_key=True, autoincrement=True)
     email = Column(String(80), unique=True, nullable=False)
     first_name = Column(String(50), nullable=False)
     last_name = Column(String(50), nullable=False)
@@ -127,11 +125,11 @@ class User(Base):
             'companies': [company.to_dict() for company in self.companies]
         }
 
-class Function(Base):
+class Tool(Base):
     """Represents a custom or system function that the LLM can call (tool)."""
-    __tablename__ = 'iat_functions'
+    __tablename__ = 'iat_tools'
 
-    id = Column(Integer, primary_key=True)
+    id = Column(Integer, primary_key=True, autoincrement=True)
     company_id = Column(Integer,
                         ForeignKey('iat_companies.id',ondelete='CASCADE'),
                         nullable=True)
@@ -142,7 +140,7 @@ class Function(Base):
     is_active = Column(Boolean, default=True)
     created_at = Column(DateTime, default=datetime.now)
 
-    company = relationship('Company', back_populates='functions')
+    company = relationship('Company', back_populates='tools')
 
     def to_dict(self):
         return {column.key: getattr(self, column.key) for column in class_mapper(self.__class__).columns}
@@ -171,7 +169,7 @@ class LLMQuery(Base):
     """Logs a query made to the LLM, including input, output, and metadata."""
     __tablename__ = 'iat_queries'
 
-    id = Column(Integer, primary_key=True)
+    id = Column(Integer, primary_key=True, autoincrement=True)
     company_id = Column(Integer, ForeignKey('iat_companies.id',
                             ondelete='CASCADE'), nullable=False)
     user_identifier = Column(String(128), nullable=False)
@@ -196,7 +194,7 @@ class VSDoc(Base):
     """Stores a text chunk and its corresponding vector embedding for similarity search."""
     __tablename__ = "iat_vsdocs"
 
-    id = Column(Integer, primary_key=True)
+    id = Column(Integer, primary_key=True, autoincrement=True)
     company_id = Column(Integer, ForeignKey('iat_companies.id',
                     ondelete='CASCADE'), nullable=False)
     document_id = Column(Integer, ForeignKey('iat_documents.id',
@@ -224,7 +222,7 @@ class TaskType(Base):
     """Defines a type of task that can be executed, including its prompt template."""
     __tablename__ = 'iat_task_types'
 
-    id = Column(Integer, primary_key=True)
+    id = Column(Integer, primary_key=True, autoincrement=True)
     name = Column(String(100), unique=True, nullable=False)
     prompt_template = Column(String(100), nullable=True)  # Plantilla de prompt por defecto.
     template_args = Column(JSON, nullable=True)  # Argumentos/prefijos de configuración para el template.
@@ -233,7 +231,7 @@ class Task(Base):
     """Represents an asynchronous task to be executed by the system, often involving an LLM."""
     __tablename__ = 'iat_tasks'
 
-    id = Column(Integer, primary_key=True)
+    id = Column(Integer, primary_key=True, autoincrement=True)
     company_id = Column(Integer, ForeignKey("iat_companies.id"))
 
     user_id = Column(Integer, nullable=True, default=0)
@@ -263,7 +261,7 @@ class UserFeedback(Base):
     """Stores feedback and ratings submitted by users for specific interactions."""
     __tablename__ = 'iat_feedback'
 
-    id = Column(Integer, primary_key=True)
+    id = Column(Integer, primary_key=True, autoincrement=True)
     company_id = Column(Integer, ForeignKey('iat_companies.id',
                                             ondelete='CASCADE'), nullable=False)
     user_identifier = Column(String(128), default='', nullable=True)
@@ -277,7 +275,7 @@ class UserFeedback(Base):
 class PromptCategory(Base):
     """Represents a category to group and organize prompts."""
     __tablename__ = 'iat_prompt_categories'
-    id = Column(Integer, primary_key=True)
+    id = Column(Integer, primary_key=True, autoincrement=True)
     name = Column(String, nullable=False)
     order = Column(Integer, nullable=False, default=0)
     company_id = Column(Integer, ForeignKey('iat_companies.id'), nullable=False)
@@ -292,7 +290,7 @@ class Prompt(Base):
     """Represents a system or user-defined prompt template for the LLM."""
     __tablename__ = 'iat_prompt'
 
-    id = Column(Integer, primary_key=True)
+    id = Column(Integer, primary_key=True, autoincrement=True)
     company_id = Column(Integer, ForeignKey('iat_companies.id',
                                             ondelete='CASCADE'), nullable=True)
     name = Column(String(64), nullable=False)
@@ -313,7 +311,7 @@ class AccessLog(Base):
     # Modelo ORM para registrar cada intento de acceso a la plataforma.
     __tablename__ = 'iat_access_log'
 
-    id = Column(BigInteger, primary_key=True)
+    id = Column(BigInteger, primary_key=True, autoincrement=True)
 
     timestamp = Column(DateTime(timezone=True), server_default=func.now(), nullable=False, index=True)
     company_short_name = Column(String(100), nullable=False, index=True)

iatoolkit/repositories/profile_repo.py

@@ -98,16 +98,11 @@ class ProfileRepo:
         search for an active API Key by its value.
         returns the entry if found and is active, None otherwise.
         """
-        try:
-            # Usamos joinedload para cargar la compañía en la misma consulta
-            api_key_entry = self.session.query(ApiKey)\
-                .options(joinedload(ApiKey.company))\
-                .filter(ApiKey.key == api_key_value, ApiKey.is_active == True)\
-                .first()
-            return api_key_entry
-        except Exception:
-            self.session.rollback() # Asegura que la sesión esté limpia tras un error
-            return None
+        api_key_entry = (self.session.query(ApiKey).filter
+                             (ApiKey.key == api_key_value, ApiKey.is_active == True).first())
+
+        return api_key_entry
+
 
     def get_active_api_key_by_company(self, company: Company) -> ApiKey | None:
         return self.session.query(ApiKey)\

iatoolkit/repositories/vs_repo.py

@@ -29,10 +29,10 @@ class VSRepo:
                 self.session.add(doc)
             self.session.commit()
         except Exception as e:
-            logging.error(f"Error inserting documents into PostgreSQL: {str(e)}")
+            logging.error(f"Error while inserting embedding chunk list: {str(e)}")
             self.session.rollback()
             raise IAToolkitException(IAToolkitException.ErrorType.VECTOR_STORE_ERROR,
-                               f"Error inserting documents into PostgreSQL: {str(e)}")
+                               f"Error while inserting embedding chunk list: {str(e)}")
 
     def query(self,
               company_short_name: str,
@@ -53,7 +53,12 @@ class VSRepo:
             list of documents matching the query and filters
         """
         # Generate the embedding with the query text for the specific company
-        query_embedding = self.embedding_service.embed_text(company_short_name, query_text)
+        try:
+            query_embedding = self.embedding_service.embed_text(company_short_name, query_text)
+        except Exception as e:
+            logging.error(f"error while creating text embedding: {str(e)}")
+            raise IAToolkitException(IAToolkitException.ErrorType.EMBEDDING_ERROR,
+                               f"embedding error: {str(e)}")
 
         sql_query, params = None, None
         try:
@@ -98,7 +103,7 @@ class VSRepo:
             sql_query = "".join(sql_query_parts)
 
             # add sorting and limit of results
-            sql_query += " ORDER BY embedding <-> :query_embedding LIMIT :n_results"
+            sql_query += " ORDER BY embedding <-> CAST(:query_embedding AS VECTOR) LIMIT :n_results"
 
             logging.debug(f"Executing SQL query: {sql_query}")
             logging.debug(f"With parameters: {params}")

iatoolkit/services/auth_service.py

@@ -132,7 +132,7 @@ class AuthService:
         # check if the api-key is valid and active
         api_key_entry = self.profile_service.get_active_api_key_entry(api_key)
         if not api_key_entry:
-            logging.info(f"Invalid or inactive API Key {api_key}")
+            logging.error(f"Invalid or inactive IAToolkit API Key: {api_key}")
             return {"success": False,
                     "error_message": self.i18n_service.t('errors.auth.invalid_api_key'),
                     "status_code": 402}

iatoolkit/services/branding_service.py

@@ -42,7 +42,7 @@ class BrandingService:
             # Estilos para Alertas de Error ---
             "brand_danger_color": "#dc3545",  # Rojo principal para alertas
             "brand_danger_bg": "#f8d7da",  # Fondo rojo pálido
-            "brand_danger_text": "#842029",  # Texto rojo oscuro
+            "brand_danger_text": "#000000",
             "brand_danger_border": "#f5c2c7",  # Borde rojo intermedio
 
             # Estilos para Alertas Informativas ---

iatoolkit/services/company_context_service.py

@@ -31,8 +31,7 @@ class CompanyContextService:
         """
         Builds the full context by aggregating three sources:
         1. Static context files (Markdown).
-        2. Static schema files (YAML for APIs, etc.).
-        3. Dynamic SQL database schema from the live connection.
+        2. Static schema files (YAML files for SQL data sources).
         """
         context_parts = []
 
@@ -44,7 +43,7 @@ class CompanyContextService:
         except Exception as e:
             logging.warning(f"Could not load Markdown context for '{company_short_name}': {e}")
 
-        # 2. Context from company-specific Python logic (SQL schemas)
+        # 2. Context from company-specific database schemas (schema/*.yaml files)
         try:
             sql_context = self._get_sql_schema_context(company_short_name)
             if sql_context:
@@ -118,6 +117,10 @@ class CompanyContextService:
             # 2. get the global settings and overrides.
             global_exclude_columns = source.get('exclude_columns', [])
             table_prefix = source.get('table_prefix')
+
+            # get the global schema definition, for this source.
+            global_schema_name = source.get('schema')
+
             table_overrides = source.get('tables', {})
 
             # 3. iterate over the tables.
@@ -126,17 +129,21 @@ class CompanyContextService:
                     # 4. get the table specific configuration.
                     table_config = table_overrides.get(table_name, {})
 
-                    # 5. define the schema name, using the override if it exists.
+                    # 5. define the schema object name, using the override if it exists.
                     # Priority 1: Explicit override from the 'tables' map.
-                    schema_name = table_config.get('schema_name')
+                    schema_object_name = table_config.get('schema_object_name')
+
+                    # Priority 2: Global schema defined in the source.
+                    if not schema_object_name and global_schema_name:
+                        schema_object_name = global_schema_name
 
-                    if not schema_name:
-                        # Priority 2: Automatic prefix stripping.
+                    if not schema_object_name:
+                        # Priority 3: Automatic prefix stripping.
                         if table_prefix and table_name.startswith(table_prefix):
-                            schema_name = table_name[len(table_prefix):]
+                            schema_object_name = table_name[len(table_prefix):]
                         else:
-                            # Priority 3: Default to the table name itself.
-                            schema_name = table_name
+                            # Priority 4: Default to the table name itself.
+                            schema_object_name = table_name
 
                     # 6. define the list of columns to exclude, (local vs. global).
                     local_exclude_columns = table_config.get('exclude_columns')
@@ -145,7 +152,8 @@ class CompanyContextService:
                     # 7. get the table schema definition.
                     table_definition = db_manager.get_table_schema(
                         table_name=table_name,
-                        schema_name=schema_name,
+                        db_schema=db_manager.schema,
+                        schema_object_name=schema_object_name,
                         exclude_columns=final_exclude_columns
                     )
                     sql_context += table_definition

iatoolkit/services/configuration_service.py

@@ -4,9 +4,14 @@
 
 from pathlib import Path
 from iatoolkit.repositories.models import Company
+from iatoolkit.repositories.llm_query_repo import LLMQueryRepo
+from iatoolkit.repositories.profile_repo import ProfileRepo
+from iatoolkit.common.exceptions import IAToolkitException
 from iatoolkit.common.util import Utility
 from injector import inject
 import logging
+import os
+
 
 class ConfigurationService:
     """
@@ -16,10 +21,22 @@ class ConfigurationService:
 
     @inject
     def __init__(self,
+                 llm_query_repo: LLMQueryRepo,
+                 profile_repo: ProfileRepo,
                  utility: Utility):
+        self.llm_query_repo = llm_query_repo
+        self.profile_repo = profile_repo
         self.utility = utility
         self._loaded_configs = {}   # cache for store loaded configurations
 
+    def _ensure_config_loaded(self, company_short_name: str):
+        """
+        Checks if the configuration for a company is in the cache.
+        If not, it loads it from files and stores it.
+        """
+        if company_short_name not in self._loaded_configs:
+            self._loaded_configs[company_short_name] = self._load_and_merge_configs(company_short_name)
+
     def get_configuration(self, company_short_name: str, content_key: str):
         """
         Public method to provide a specific section of a company's configuration.
@@ -39,28 +56,26 @@ class ConfigurationService:
         config = self._load_and_merge_configs(company_short_name)
 
         # 2. Register core company details and get the database object
-        company_db_object = self._register_core_details(company_instance, config)
+        self._register_core_details(company_instance, config)
+
+        # 3. Register databases
+        self._register_data_sources(company_short_name, config)
 
-        # 3. Register tools (functions)
-        self._register_tools(company_instance, config.get('tools', []))
+        # 4. Register tools
+        self._register_tools(company_instance, config)
 
-        # 4. Register prompt categories and prompts
+        # 5. Register prompt categories and prompts
         self._register_prompts(company_instance, config)
 
-        # 5. Link the persisted Company object back to the running instance
+        # 6. Link the persisted Company object back to the running instance
         company_instance.company_short_name = company_short_name
-        company_instance.company = company_db_object
         company_instance.id = company_instance.company.id
 
+        # Final step: validate the configuration against platform
+        self._validate_configuration(company_short_name, config)
+
         logging.info(f"✅ Company '{company_short_name}' configured successfully.")
 
-    def _ensure_config_loaded(self, company_short_name: str):
-        """
-        Checks if the configuration for a company is in the cache.
-        If not, it loads it from files and stores it.
-        """
-        if company_short_name not in self._loaded_configs:
-            self._loaded_configs[company_short_name] = self._load_and_merge_configs(company_short_name)
 
     def _load_and_merge_configs(self, company_short_name: str) -> dict:
         """
@@ -87,47 +102,205 @@ class ConfigurationService:
         return config
 
     def _register_core_details(self, company_instance, config: dict) -> Company:
-        """Calls _create_company with data from the merged YAML config."""
-        return company_instance._create_company(
-            short_name=config['id'],
-            name=config['name'],
-            parameters=config.get('parameters', {})
-        )
+        # register the company in the database: create_or_update logic
 
-    def _register_tools(self, company_instance, tools_config: list):
-        """Calls _create_function for each tool defined in the YAML."""
-        for tool in tools_config:
-            company_instance._create_function(
-                function_name=tool['function_name'],
-                description=tool['description'],
-                params=tool['params']
-            )
+        company_obj = Company(short_name=config['id'],
+                              name=config['name'],
+                              parameters=config.get('parameters', {}))
+        company = self.profile_repo.create_company(company_obj)
 
-    def _register_prompts(self, company_instance, config: dict):
+        # save company object with the instance
+        company_instance.company = company
+        return company
+
+    def _register_data_sources(self, company_short_name: str, config: dict):
         """
-        Creates prompt categories first, then creates each prompt and assigns
-        it to its respective category.
+        Reads the data_sources config and registers databases with SqlService.
+        Uses Lazy Loading to avoid circular dependency.
+        """
+        # Lazy import to avoid circular dependency: ConfigService -> SqlService -> I18n -> ConfigService
+        from iatoolkit import current_iatoolkit
+        from iatoolkit.services.sql_service import SqlService
+        sql_service = current_iatoolkit().get_injector().get(SqlService)
+
+        data_sources = config.get('data_sources', {})
+        sql_sources = data_sources.get('sql', [])
+
+        if not sql_sources:
+            return
+
+        logging.info(f"🛢️ Registering databases for '{company_short_name}'...")
+
+        for db_config in sql_sources:
+            db_name = db_config.get('database')
+            db_schema = db_config.get('schema', 'public')
+            db_env_var = db_config.get('connection_string_env')
+
+            # resolve the URI
+            db_uri = os.getenv(db_env_var) if db_env_var else None
+
+            if not db_uri:
+                logging.error(
+                    f"-> Skipping DB '{db_name}' for '{company_short_name}': missing URI in env '{db_env_var}'.")
+                continue
+
+            # Register with the SQL service
+            sql_service.register_database(db_uri, db_name, db_schema)
+
+    def _register_tools(self, company_instance, config: dict):
+        """creates in the database each tool defined in the YAML."""
+        # Lazy import and resolve ToolService locally
+        from iatoolkit import current_iatoolkit
+        from iatoolkit.services.tool_service import ToolService
+        tool_service = current_iatoolkit().get_injector().get(ToolService)
+
+        tools_config = config.get('tools', [])
+        tool_service.sync_company_tools(company_instance, tools_config)
+
+    def _register_prompts(self, company_instance, config: dict):
         """
+         Delegates prompt synchronization to PromptService.
+         """
+        # Lazy import to avoid circular dependency
+        from iatoolkit import current_iatoolkit
+        from iatoolkit.services.prompt_service import PromptService
+        prompt_service = current_iatoolkit().get_injector().get(PromptService)
+
         prompts_config = config.get('prompts', [])
         categories_config = config.get('prompt_categories', [])
 
-        created_categories = {}
-        for i, category_name in enumerate(categories_config):
-            category_obj = company_instance._create_prompt_category(name=category_name, order=i + 1)
-            created_categories[category_name] = category_obj
+        prompt_service.sync_company_prompts(
+            company_instance=company_instance,
+            prompts_config=prompts_config,
+            categories_config=categories_config
+        )
+
+    def _validate_configuration(self, company_short_name: str, config: dict):
+        """
+        Validates the structure and consistency of the company.yaml configuration.
+        It checks for required keys, valid values, and existence of related files.
+        Raises IAToolkitException if any validation error is found.
+        """
+        errors = []
+        config_dir = Path("companies") / company_short_name / "config"
+        prompts_dir = Path("companies") / company_short_name / "prompts"
+
+        # Helper to collect errors
+        def add_error(section, message):
+            errors.append(f"[{section}] {message}")
+
+        # 1. Top-level keys
+        if not config.get("id"):
+            add_error("General", "Missing required key: 'id'")
+        elif config["id"] != company_short_name:
+            add_error("General",
+                      f"'id' ({config['id']}) does not match the company short name ('{company_short_name}').")
+        if not config.get("name"):
+            add_error("General", "Missing required key: 'name'")
+
+        # 2. LLM section
+        if not isinstance(config.get("llm"), dict):
+            add_error("llm", "Missing or invalid 'llm' section.")
+        else:
+            if not config.get("llm", {}).get("model"):
+                add_error("llm", "Missing required key: 'model'")
+            if not config.get("llm", {}).get("api-key"):
+                add_error("llm", "Missing required key: 'api-key'")
 
-        for prompt_data in prompts_config:
-            category_name = prompt_data.get('category')
-            if not category_name or category_name not in created_categories:
-                logging.info(f"⚠️  Warning: Prompt '{prompt_data['name']}' has an invalid or missing category. Skipping.")
+        # 3. Embedding Provider
+        if isinstance(config.get("embedding_provider"), dict):
+            if not config.get("embedding_provider", {}).get("provider"):
+                add_error("embedding_provider", "Missing required key: 'provider'")
+            if not config.get("embedding_provider", {}).get("model"):
+                add_error("embedding_provider", "Missing required key: 'model'")
+            if not config.get("embedding_provider", {}).get("api_key_name"):
+                add_error("embedding_provider", "Missing required key: 'api_key_name'")
+
+        # 4. Data Sources
+        for i, source in enumerate(config.get("data_sources", {}).get("sql", [])):
+            if not source.get("database"):
+                add_error(f"data_sources.sql[{i}]", "Missing required key: 'database'")
+            if not source.get("connection_string_env"):
+                add_error(f"data_sources.sql[{i}]", "Missing required key: 'connection_string_env'")
+
+        # 5. Tools
+        for i, tool in enumerate(config.get("tools", [])):
+            function_name = tool.get("function_name")
+            if not function_name:
+                add_error(f"tools[{i}]", "Missing required key: 'function_name'")
+
+            # check that function exist in dispatcher
+            if not tool.get("description"):
+                add_error(f"tools[{i}]", "Missing required key: 'description'")
+            if not isinstance(tool.get("params"), dict):
+                add_error(f"tools[{i}]", "'params' key must be a dictionary.")
+
+        # 6. Prompts
+        category_set = set(config.get("prompt_categories", []))
+        for i, prompt in enumerate(config.get("prompts", [])):
+            prompt_name = prompt.get("name")
+            if not prompt_name:
+                add_error(f"prompts[{i}]", "Missing required key: 'name'")
+            else:
+                prompt_file = prompts_dir / f"{prompt_name}.prompt"
+                if not prompt_file.is_file():
+                    add_error(f"prompts/{prompt_name}:", f"Prompt file not found: {prompt_file}")
+
+                prompt_description = prompt.get("description")
+                if not prompt_description:
+                    add_error(f"prompts[{i}]", "Missing required key: 'description'")
+
+            prompt_cat = prompt.get("category")
+            if not prompt_cat:
+                add_error(f"prompts[{i}]", "Missing required key: 'category'")
+            elif prompt_cat not in category_set:
+                add_error(f"prompts[{i}]", f"Category '{prompt_cat}' is not defined in 'prompt_categories'.")
+
+        # 7. User Feedback
+        feedback_config = config.get("parameters", {}).get("user_feedback", {})
+        if feedback_config.get("channel") == "email" and not feedback_config.get("destination"):
+            add_error("parameters.user_feedback", "When channel is 'email', a 'destination' is required.")
+
+        # 8. Knowledge Base
+        kb_config = config.get("knowledge_base", {})
+        if kb_config and not isinstance(kb_config, dict):
+            add_error("knowledge_base", "Section must be a dictionary.")
+        elif kb_config:
+            prod_connector = kb_config.get("connectors", {}).get("production", {})
+            if prod_connector.get("type") == "s3":
+                for key in ["bucket", "prefix", "aws_access_key_id_env", "aws_secret_access_key_env", "aws_region_env"]:
+                    if not prod_connector.get(key):
+                        add_error("knowledge_base.connectors.production", f"S3 connector is missing '{key}'.")
+
+        # 9. Mail Provider
+        mail_config = config.get("mail_provider", {})
+        if mail_config:
+            provider = mail_config.get("provider")
+            if not provider:
+                add_error("mail_provider", "Missing required key: 'provider'")
+            elif provider not in ["brevo_mail", "smtplib"]:
+                add_error("mail_provider", f"Unsupported provider: '{provider}'. Must be 'brevo_mail' or 'smtplib'.")
+
+            if not mail_config.get("sender_email"):
+                add_error("mail_provider", "Missing required key: 'sender_email'")
+
+        # 10. Help Files
+        for key, filename in config.get("help_files", {}).items():
+            if not filename:
+                add_error(f"help_files.{key}", "Filename cannot be empty.")
                 continue
+            help_file_path = config_dir / filename
+            if not help_file_path.is_file():
+                add_error(f"help_files.{key}", f"Help file not found: {help_file_path}")
+
+        # If any errors were found, log all messages and raise an exception
+        if errors:
+            error_summary = f"Configuration file '{company_short_name}/config/company.yaml' for '{company_short_name}' has validation errors:\n" + "\n".join(
+                f" - {e}" for e in errors)
+            logging.error(error_summary)
 
-            category_obj = created_categories[category_name]
-            company_instance._create_prompt(
-                prompt_name=prompt_data['name'],
-                description=prompt_data['description'],
-                order=prompt_data['order'],
-                category=category_obj,
-                active=prompt_data.get('active', True),
-                custom_fields=prompt_data.get('custom_fields', [])
+            raise IAToolkitException(
+                IAToolkitException.ErrorType.CONFIG_ERROR,
+                'company.yaml validation errors'
             )
+