- Introduction of dynamic Retrievers & Specialists

- Introduction of dynamic Processors
- Introduction of caching system
- Introduction of a better template manager
- Adaptation of ModelVariables to support dynamic Processors / Retrievers / Specialists
- Start adaptation of chat client

eveai_app/views/dynamic_form_base.py

@@ -5,6 +5,7 @@ import json
 
 from wtforms.fields.choices import SelectField
 from wtforms.fields.datetime import DateField
+from common.utils.config_field_types import TaggingFields
 
 
 class DynamicFormBase(FlaskForm):
@@ -38,14 +39,35 @@ class DynamicFormBase(FlaskForm):
                         message=f"Value must be between {min_value or '-∞'} and {max_value or '∞'}"
                     )
                 )
+        elif field_type == 'tagging_fields':
+            validators_list.append(self._validate_tagging_fields)
 
         return validators_list
 
+    def _validate_tagging_fields(self, form, field):
+        """Validate the tagging fields structure"""
+        if not field.data:
+            return
+
+        try:
+            # Parse JSON data
+            fields_data = json.loads(field.data)
+
+            # Validate using TaggingFields model
+            try:
+                TaggingFields.from_dict(fields_data)
+            except ValueError as e:
+                raise ValidationError(str(e))
+
+        except json.JSONDecodeError:
+            raise ValidationError("Invalid JSON format")
+        except Exception as e:
+            raise ValidationError(f"Invalid field definition: {str(e)}")
+
     def add_dynamic_fields(self, collection_name, config, initial_data=None):
         """Add dynamic fields to the form based on the configuration."""
         self.dynamic_fields[collection_name] = []
         for field_name, field_def in config.items():
-            current_app.logger.debug(f"{field_name}: {field_def}")
             # Prefix the field name with the collection name
             full_field_name = f"{collection_name}_{field_name}"
             label = field_def.get('name', field_name)
@@ -59,7 +81,6 @@ class DynamicFormBase(FlaskForm):
             # Handle special case for tagging_fields
             if field_type == 'tagging_fields':
                 field_class = TextAreaField
-                field_validators.append(validate_tagging_fields)
                 extra_classes = 'json-editor'
                 field_kwargs = {}
             elif field_type == 'enum':
@@ -145,16 +166,12 @@ class DynamicFormBase(FlaskForm):
     def get_dynamic_data(self, collection_name):
         """Retrieve the data from dynamic fields of a specific collection."""
         data = {}
-        current_app.logger.debug(f"{collection_name} in {self.dynamic_fields}?")
         if collection_name not in self.dynamic_fields:
             return data
         prefix_length = len(collection_name) + 1  # +1 for the underscore
         for full_field_name in self.dynamic_fields[collection_name]:
-            current_app.logger.debug(f"{full_field_name}: {full_field_name}")
             original_field_name = full_field_name[prefix_length:]
-            current_app.logger.debug(f"{original_field_name}: {original_field_name}")
             field = getattr(self, full_field_name)
-            current_app.logger.debug(f"{field}: {field}")
             # Parse JSON for tagging_fields type
             if isinstance(field, TextAreaField) and field.data:
                 try: