unique_toolkit 1.45.5__py3-none-any.whl → 1.45.6__py3-none-any.whl

unique_toolkit/agentic/evaluation/hallucination/utils.py

@@ -1,9 +1,13 @@
-import logging
-from enum import StrEnum
-from string import Template
+import re
+from logging import getLogger
 
+from unique_toolkit._common.utils.jinja.render import render_template
 from unique_toolkit.agentic.evaluation.config import EvaluationMetricConfig
 from unique_toolkit.agentic.evaluation.exception import EvaluatorException
+from unique_toolkit.agentic.evaluation.hallucination.constants import (
+    SourceSelectionMode,
+    hallucination_required_input_fields,
+)
 from unique_toolkit.agentic.evaluation.output_parser import parse_eval_metric_result
 from unique_toolkit.agentic.evaluation.schemas import (
     EvaluationMetricInput,
@@ -20,19 +24,7 @@ from unique_toolkit.language_model.schemas import (
 )
 from unique_toolkit.language_model.service import LanguageModelService
 
-from .constants import (
-    SYSTEM_MSG_DEFAULT_KEY,
-    SYSTEM_MSG_KEY,
-    USER_MSG_DEFAULT_KEY,
-    USER_MSG_KEY,
-    hallucination_required_input_fields,
-)
-from .prompts import (
-    HALLUCINATION_METRIC_SYSTEM_MSG,
-    HALLUCINATION_METRIC_SYSTEM_MSG_DEFAULT,
-    HALLUCINATION_METRIC_USER_MSG,
-    HALLUCINATION_METRIC_USER_MSG_DEFAULT,
-)
+_LOGGER = getLogger(__name__)
 
 
 async def check_hallucination(
@@ -72,15 +64,14 @@ async def check_hallucination(
         EvaluatorException: If the context texts are empty, required fields are missing, or an error occurs during the evaluation.
     """
 
-    logger = logging.getLogger(f"check_hallucination.{__name__}")
-
     model_name = config.language_model.name
-    logger.info(f"Analyzing level of hallucination with {model_name}.")
+    _LOGGER.info(f"Analyzing level of hallucination with {model_name}.")
 
     input.validate_required_fields(hallucination_required_input_fields)
 
     try:
-        msgs = _get_msgs(input, config, logger)
+        msgs = _get_msgs(input, config)
+
         result = await LanguageModelService.complete_async_util(
             company_id=company_id, user_id=user_id, messages=msgs, model_name=model_name
         )
@@ -91,10 +82,12 @@ async def check_hallucination(
                 error_message=error_message,
                 user_message=error_message,
             )
-        return parse_eval_metric_result(
+        result = parse_eval_metric_result(
             result_content,  # type: ignore
             EvaluationMetricName.HALLUCINATION,
         )
+
+        return result
     except Exception as e:
         error_message = "Error occurred during hallucination metric analysis"
         raise EvaluatorException(
@@ -107,131 +100,142 @@ async def check_hallucination(
 def _get_msgs(
     input: EvaluationMetricInput,
     config: EvaluationMetricConfig,
-    logger: logging.Logger,
 ):
     """
     Composes the messages for hallucination analysis based on the provided input and configuration.
 
-    This method decides how to compose the messages based on the availability of context texts and history
-    message texts in the `input`
+    This method composes messages with or without context based on the availability of context texts
+    and history message texts in the input.
 
     Args:
         input (EvaluationMetricInput): The input data that includes context texts and history message texts
                                       for the analysis.
         config (EvaluationMetricConfig): The configuration settings for composing messages.
         logger (Optional[logging.Logger], optional): The logger used for logging debug information.
-                                                     Defaults to the logger for the current module.
 
     Returns:
-        The composed messages as per the provided input and configuration. The exact type and structure
-        depend on the implementation of the `compose_msgs` and `compose_msgs_default` methods.
-
+        The composed messages as per the provided input and configuration.
     """
-    if input.context_texts or input.history_messages:
-        logger.debug("Using context / history for hallucination evaluation.")
-        return _compose_msgs(input, config)
+    has_context = bool(input.context_texts or input.history_messages)
+
+    if has_context:
+        _LOGGER.debug("Using context / history for hallucination evaluation.")
     else:
-        logger.debug("No contexts and history provided for hallucination evaluation.")
-        return _compose_msgs_default(input, config)
+        _LOGGER.debug("No contexts and history provided for hallucination evaluation.")
+
+    return _compose_msgs(input, config, has_context)
 
 
 def _compose_msgs(
     input: EvaluationMetricInput,
     config: EvaluationMetricConfig,
+    has_context: bool,
 ):
     """
-    Composes the hallucination analysis messages.
-    """
-    system_msg_content = _get_system_prompt_with_contexts(config)
-    system_msg = LanguageModelSystemMessage(content=system_msg_content)
-
-    user_msg_templ = Template(_get_user_prompt_with_contexts(config))
-    user_msg_content = user_msg_templ.substitute(
-        input_text=input.input_text,
-        contexts_text=input.get_joined_context_texts(tag_name="reference"),
-        history_messages_text=input.get_joined_history_texts(tag_name="conversation"),
-        output_text=input.output_text,
-    )
-    user_msg = LanguageModelUserMessage(content=user_msg_content)
-    return LanguageModelMessages([system_msg, user_msg])
+    Composes the hallucination analysis messages using Jinja2 templates.
 
+    Args:
+        input (EvaluationMetricInput): The input data for evaluation.
+        config (EvaluationMetricConfig): The configuration settings.
+        has_context (bool): Whether context/history is available.
 
-def _compose_msgs_default(
-    input: EvaluationMetricInput,
-    config: EvaluationMetricConfig,
-):
-    """
-    Composes the hallucination analysis prompt without messages.
+    Returns:
+        LanguageModelMessages: The composed messages for evaluation.
     """
-    system_msg_content = _get_system_prompt_default(config)
+    # Get templates
+    system_template = config.prompts_config.system_prompt_template
+    user_template = config.prompts_config.user_prompt_template
+
+    # Render system message
+    system_msg_content = render_template(
+        system_template,
+        has_context=has_context,
+    )
     system_msg = LanguageModelSystemMessage(content=system_msg_content)
 
-    user_msg_templ = Template(_get_user_prompt_default(config))
-    user_msg_content = user_msg_templ.substitute(
+    # Render user message
+    user_msg_content = render_template(
+        user_template,
         input_text=input.input_text,
+        contexts_text=input.get_joined_context_texts(tag_name="reference")
+        if has_context
+        else None,
+        history_messages_text=input.get_joined_history_texts(tag_name="conversation")
+        if has_context
+        else None,
         output_text=input.output_text,
     )
     user_msg = LanguageModelUserMessage(content=user_msg_content)
-    return LanguageModelMessages([system_msg, user_msg])
-
-
-def _get_system_prompt_with_contexts(config: EvaluationMetricConfig):
-    return config.custom_prompts.setdefault(
-        SYSTEM_MSG_KEY,
-        HALLUCINATION_METRIC_SYSTEM_MSG,
-    )
-
-
-def _get_user_prompt_with_contexts(config: EvaluationMetricConfig):
-    return config.custom_prompts.setdefault(
-        USER_MSG_KEY,
-        HALLUCINATION_METRIC_USER_MSG,
-    )
 
+    return LanguageModelMessages([system_msg, user_msg])
 
-def _get_system_prompt_default(config: EvaluationMetricConfig):
-    return config.custom_prompts.setdefault(
-        SYSTEM_MSG_DEFAULT_KEY,
-        HALLUCINATION_METRIC_SYSTEM_MSG_DEFAULT,
-    )
 
+def context_text_from_stream_response(
+    response: LanguageModelStreamResponse,
+    selected_chunks: list[ContentChunk],
+    source_selection_mode: SourceSelectionMode = SourceSelectionMode.FROM_ORIGINAL_RESPONSE,
+    reference_pattern: str = r"[\[<]?source(\d+)[>\]]?",
+) -> list[str]:
+    """Extract context text from stream response based on selected chunks.
 
-def _get_user_prompt_default(config: EvaluationMetricConfig):
-    return config.custom_prompts.setdefault(
-        USER_MSG_DEFAULT_KEY,
-        HALLUCINATION_METRIC_USER_MSG_DEFAULT,
-    )
+    Args:
+        response: The language model stream response containing references.
+        selected_chunks: List of content chunks to select from.
+        source_selection_mode: Strategy for selecting referenced chunks.
+            - FROM_IDS: Match by chunk IDs (default)
+            - FROM_ORDER: Select by order of appearance
+            - FROM_ORIGINAL_RESPONSE: Extract from original response text using regex
+        ref_pattern: Regex pattern for extracting source numbers (only used with FROM_ORIGINAL_RESPONSE).
 
+    Returns:
+        List of text strings from the referenced chunks.
 
-class SourceSelectionMode(StrEnum):
-    FROM_IDS = "FROM_IDS"
-    FROM_ORDER = "FROM_ORDER"
+    Raises:
+        ValueError: If source_selection_mode is invalid or required data is missing.
+    """
+    response_references = response.message.references
 
+    # Define selection strategies
+    strategies = {
+        SourceSelectionMode.FROM_IDS: lambda: _default_source_selection_mode(
+            response_references, selected_chunks
+        ),
+        SourceSelectionMode.FROM_ORDER: lambda: _from_order_source_selection_mode(
+            response_references, selected_chunks
+        ),
+        SourceSelectionMode.FROM_ORIGINAL_RESPONSE: lambda: _from_original_response_source_selection_mode(
+            response.message.original_text, selected_chunks, reference_pattern
+        ),
+    }
 
-def context_text_from_stream_response(
-    response: LanguageModelStreamResponse,
-    selected_chunks: list[ContentChunk],
-    source_selection_mode: SourceSelectionMode = SourceSelectionMode.FROM_IDS,
-):
-    response_references = response.message.references
-    match source_selection_mode:
-        case SourceSelectionMode.FROM_IDS:
-            referenced_chunks = _default_source_selection_mode(
-                response_references, selected_chunks
-            )
-        case SourceSelectionMode.FROM_ORDER:
-            referenced_chunks = _from_order_source_selection_mode(
-                response_references, selected_chunks
-            )
-        case _:
+    try:
+        if source_selection_mode not in strategies:
             raise ValueError(f"Invalid source selection mode: {source_selection_mode}")
 
+        _LOGGER.info(f"Selecting context text using {source_selection_mode} mode.")
+        referenced_chunks = strategies[source_selection_mode]()
+    except Exception as e:
+        _LOGGER.exception(f"Error selecting context text: {e}")
+        _LOGGER.info("Falling back to default source selection mode.")
+        referenced_chunks = _default_source_selection_mode(
+            response_references, selected_chunks
+        )
+
     return [chunk.text for chunk in referenced_chunks]
 
 
 def _default_source_selection_mode(
     references: list[ContentReference], selected_chunks: list[ContentChunk]
-):
+) -> list[ContentChunk]:
+    """Select chunks by matching reference IDs.
+
+    Args:
+        references: List of content references with source IDs.
+        selected_chunks: List of content chunks to select from.
+
+    Returns:
+        List of referenced content chunks.
+    """
     reference_ids = {reference.source_id for reference in references}
 
     def build_chunk_id(chunk: ContentChunk) -> str:
@@ -246,7 +250,16 @@ def _default_source_selection_mode(
 
 def _from_order_source_selection_mode(
     references: list[ContentReference], selected_chunks: list[ContentChunk]
-):
+) -> list[ContentChunk]:
+    """Select chunks by order of appearance in references.
+
+    Args:
+        references: List of content references with original indices.
+        selected_chunks: List of content chunks to select from.
+
+    Returns:
+        List of referenced content chunks in order of appearance.
+    """
     original_chunks_order: list[int] = []
     for reference in references:
         for original_index in reference.original_index:
@@ -258,3 +271,41 @@ def _from_order_source_selection_mode(
         referenced_chunks.append(selected_chunks[index])
 
     return referenced_chunks
+
+
+def _from_original_response_source_selection_mode(
+    original_text: str | None,
+    selected_chunks: list[ContentChunk],
+    reference_pattern: str,
+) -> list[ContentChunk]:
+    """Extract referenced chunks from original text using regex pattern.
+
+    Args:
+        original_text: The original response text containing source references.
+        selected_chunks: List of content chunks to select from.
+        ref_pattern: Regex pattern for extracting source numbers.
+
+    Returns:
+        List of referenced content chunks.
+    """
+    if original_text is None:
+        raise ValueError("original_text is required for FROM_ORIGINAL_RESPONSE mode")
+    _LOGGER.debug("Processing original text for source extraction")
+    source_number_matches = re.findall(reference_pattern, original_text)
+
+    # Remove duplicates and preserve order
+    source_numbers = list(dict.fromkeys(int(num) for num in source_number_matches))
+
+    # Add bounds checking
+    max_index = len(selected_chunks) - 1
+    valid_source_numbers = [idx for idx in source_numbers if 0 <= idx <= max_index]
+
+    if len(valid_source_numbers) < len(source_numbers):
+        invalid_numbers = set(source_numbers) - set(valid_source_numbers)
+        _LOGGER.warning(
+            f"Some source indices were out of bounds (max index: {max_index}). "
+            f"Valid indices: {sorted(valid_source_numbers)}, Invalid indices: {sorted(invalid_numbers)}"
+        )
+
+    referenced_chunks = [selected_chunks[idx] for idx in valid_source_numbers]
+    return referenced_chunks

unique_toolkit/agentic/evaluation/tests/fixtures.py

@@ -0,0 +1,102 @@
+"""Centralized fixtures for evaluation tests."""
+
+from unittest.mock import MagicMock
+
+import pytest
+
+from unique_toolkit.agentic.evaluation.config import EvaluationMetricConfig
+from unique_toolkit.agentic.evaluation.context_relevancy.service import (
+    ContextRelevancyEvaluator,
+)
+from unique_toolkit.agentic.evaluation.schemas import (
+    EvaluationMetricInput,
+    EvaluationMetricName,
+)
+from unique_toolkit.app.schemas import ChatEvent
+from unique_toolkit.chat.service import LanguageModelName
+from unique_toolkit.language_model.infos import LanguageModelInfo
+
+
+@pytest.fixture
+def base_chat_event() -> MagicMock:
+    """
+    Create a base chat event mock for evaluation tests.
+
+    Returns:
+        MagicMock configured with standard test event properties.
+    """
+    event = MagicMock(spec=ChatEvent)
+    event.payload = MagicMock()
+    event.payload.user_message = MagicMock()
+    event.payload.user_message.text = "Test query"
+    event.user_id = "user_0"
+    event.company_id = "company_0"
+    return event
+
+
+@pytest.fixture
+def context_relevancy_evaluator(
+    base_chat_event: MagicMock,
+) -> ContextRelevancyEvaluator:
+    """
+    Create a ContextRelevancyEvaluator instance with base event.
+
+    Args:
+        base_chat_event: Mock chat event fixture.
+
+    Returns:
+        Configured ContextRelevancyEvaluator instance.
+    """
+    return ContextRelevancyEvaluator(base_chat_event)
+
+
+@pytest.fixture
+def basic_evaluation_config() -> EvaluationMetricConfig:
+    """
+    Create a basic evaluation config for context relevancy tests.
+
+    Returns:
+        EvaluationMetricConfig with standard settings.
+    """
+    return EvaluationMetricConfig(
+        enabled=True,
+        name=EvaluationMetricName.CONTEXT_RELEVANCY,
+        language_model=LanguageModelInfo.from_name(
+            LanguageModelName.AZURE_GPT_4o_2024_0806
+        ),
+    )
+
+
+@pytest.fixture
+def structured_evaluation_config(
+    basic_evaluation_config: EvaluationMetricConfig,
+) -> EvaluationMetricConfig:
+    """
+    Create evaluation config with structured output enabled.
+
+    Args:
+        basic_evaluation_config: Base config fixture.
+
+    Returns:
+        EvaluationMetricConfig configured for structured output.
+    """
+    model_info = LanguageModelInfo.from_name(LanguageModelName.AZURE_GPT_4o_2024_0806)
+    return EvaluationMetricConfig(
+        enabled=True,
+        name=EvaluationMetricName.CONTEXT_RELEVANCY,
+        language_model=model_info,
+    )
+
+
+@pytest.fixture
+def sample_evaluation_input() -> EvaluationMetricInput:
+    """
+    Create sample evaluation input with test data.
+
+    Returns:
+        EvaluationMetricInput with test query and contexts.
+    """
+    return EvaluationMetricInput(
+        input_text="test query",
+        context_texts=["test context 1", "test context 2"],
+    )

unique_toolkit/agentic/evaluation/tests/test_config.py

@@ -0,0 +1,247 @@
+"""Tests for evaluation config module."""
+
+import pytest
+
+from unique_toolkit.agentic.evaluation.config import (
+    EvaluationMetricConfig,
+    EvaluationMetricPromptsConfig,
+)
+from unique_toolkit.agentic.evaluation.schemas import EvaluationMetricName
+from unique_toolkit.language_model.default_language_model import DEFAULT_GPT_4o
+from unique_toolkit.language_model.infos import LanguageModelInfo
+
+
+@pytest.mark.ai
+def test_evaluation_metric_prompts_config__initializes_with_empty_strings__by_default() -> (
+    None
+):
+    """
+    Purpose: Verify that EvaluationMetricPromptsConfig initializes with empty template strings.
+    Why this matters: Default initialization should not load templates automatically.
+    Setup summary: Create config with no arguments, assert empty string defaults.
+    """
+    # Arrange - No setup needed
+
+    # Act
+    config: EvaluationMetricPromptsConfig = EvaluationMetricPromptsConfig()
+
+    # Assert
+    assert config.system_prompt_template == ""
+    assert config.user_prompt_template == ""
+
+
+@pytest.mark.ai
+def test_evaluation_metric_prompts_config__accepts_custom_templates__on_initialization() -> (
+    None
+):
+    """
+    Purpose: Verify that EvaluationMetricPromptsConfig accepts custom template values.
+    Why this matters: Allows customization of prompts for different evaluation scenarios.
+    Setup summary: Initialize with custom prompts, assert they are stored correctly.
+    """
+    # Arrange
+    system_prompt: str = "Custom system prompt"
+    user_prompt: str = "Custom user prompt"
+
+    # Act
+    config: EvaluationMetricPromptsConfig = EvaluationMetricPromptsConfig(
+        system_prompt_template=system_prompt,
+        user_prompt_template=user_prompt,
+    )
+
+    # Assert
+    assert config.system_prompt_template == system_prompt
+    assert config.user_prompt_template == user_prompt
+
+
+@pytest.mark.ai
+def test_evaluation_metric_prompts_config__stores_strings__for_template_fields() -> (
+    None
+):
+    """
+    Purpose: Verify that prompt template fields accept and store string values.
+    Why this matters: Type safety for prompt templates is critical for rendering.
+    Setup summary: Create config with string prompts, assert type is string.
+    """
+    # Arrange
+    system_template: str = "Test system prompt"
+    user_template: str = "Test user prompt"
+
+    # Act
+    config: EvaluationMetricPromptsConfig = EvaluationMetricPromptsConfig(
+        system_prompt_template=system_template,
+        user_prompt_template=user_template,
+    )
+
+    # Assert
+    assert isinstance(config.system_prompt_template, str)
+    assert isinstance(config.user_prompt_template, str)
+
+
+@pytest.mark.ai
+def test_evaluation_metric_prompts_config__allows_modification__after_initialization() -> (
+    None
+):
+    """
+    Purpose: Verify that prompt config fields can be modified after creation.
+    Why this matters: Enables dynamic prompt updates during runtime.
+    Setup summary: Create config, modify fields, assert new values.
+    """
+    # Arrange
+    config: EvaluationMetricPromptsConfig = EvaluationMetricPromptsConfig()
+
+    # Act
+    config.system_prompt_template = "New system prompt"
+    config.user_prompt_template = "New user prompt"
+
+    # Assert
+    assert config.system_prompt_template == "New system prompt"
+    assert config.user_prompt_template == "New user prompt"
+
+
+@pytest.mark.ai
+def test_evaluation_metric_config__initializes_with_default_prompts_config__when_not_provided() -> (
+    None
+):
+    """
+    Purpose: Verify that EvaluationMetricConfig creates default prompts config.
+    Why this matters: Ensures config is always in valid state even without explicit prompts.
+    Setup summary: Create config without prompts_config, assert default empty prompts.
+    """
+    # Arrange - No setup needed
+
+    # Act
+    config: EvaluationMetricConfig = EvaluationMetricConfig(
+        enabled=True,
+        name=EvaluationMetricName.CONTEXT_RELEVANCY,
+    )
+
+    # Assert
+    assert isinstance(config.prompts_config, EvaluationMetricPromptsConfig)
+    assert config.prompts_config.system_prompt_template == ""
+    assert config.prompts_config.user_prompt_template == ""
+
+
+@pytest.mark.ai
+def test_evaluation_metric_config__accepts_custom_prompts_config__on_initialization() -> (
+    None
+):
+    """
+    Purpose: Verify that EvaluationMetricConfig accepts custom prompts configuration.
+    Why this matters: Allows full customization of evaluation prompts per metric.
+    Setup summary: Create custom prompts config, pass to metric config, assert values.
+    """
+    # Arrange
+    prompts_config: EvaluationMetricPromptsConfig = EvaluationMetricPromptsConfig(
+        system_prompt_template="Custom system",
+        user_prompt_template="Custom user",
+    )
+
+    # Act
+    config: EvaluationMetricConfig = EvaluationMetricConfig(
+        enabled=True,
+        name=EvaluationMetricName.CONTEXT_RELEVANCY,
+        prompts_config=prompts_config,
+    )
+
+    # Assert
+    assert config.prompts_config.system_prompt_template == "Custom system"
+    assert config.prompts_config.user_prompt_template == "Custom user"
+
+
+@pytest.mark.ai
+def test_evaluation_metric_config__has_all_required_fields__on_initialization() -> None:
+    """
+    Purpose: Verify that EvaluationMetricConfig has all expected configuration fields.
+    Why this matters: Ensures complete config structure for evaluation metrics.
+    Setup summary: Create config with language model, assert all fields exist.
+    """
+    # Arrange
+    language_model: LanguageModelInfo = LanguageModelInfo.from_name(DEFAULT_GPT_4o)
+
+    # Act
+    config: EvaluationMetricConfig = EvaluationMetricConfig(
+        enabled=True,
+        name=EvaluationMetricName.HALLUCINATION,
+        language_model=language_model,
+    )
+
+    # Assert
+    assert hasattr(config, "enabled")
+    assert hasattr(config, "name")
+    assert hasattr(config, "language_model")
+    assert hasattr(config, "additional_llm_options")
+    assert hasattr(config, "prompts_config")
+    assert hasattr(config, "score_to_label")
+    assert hasattr(config, "score_to_title")
+
+
+@pytest.mark.ai
+def test_evaluation_metric_config__defaults_to_empty_dict__for_additional_llm_options() -> (
+    None
+):
+    """
+    Purpose: Verify that additional_llm_options defaults to empty dictionary.
+    Why this matters: Provides safe default for optional LLM configuration.
+    Setup summary: Create config without options, assert empty dict default.
+    """
+    # Arrange - No setup needed
+
+    # Act
+    config: EvaluationMetricConfig = EvaluationMetricConfig(
+        enabled=True,
+        name=EvaluationMetricName.CONTEXT_RELEVANCY,
+    )
+
+    # Assert
+    assert config.additional_llm_options == {}
+    assert isinstance(config.additional_llm_options, dict)
+
+
+@pytest.mark.ai
+def test_evaluation_metric_config__defaults_to_empty_dicts__for_score_mappings() -> (
+    None
+):
+    """
+    Purpose: Verify that score mapping dictionaries default to empty.
+    Why this matters: Allows optional score labeling and titling per metric.
+    Setup summary: Create config without mappings, assert empty dict defaults.
+    """
+    # Arrange - No setup needed
+
+    # Act
+    config: EvaluationMetricConfig = EvaluationMetricConfig(
+        enabled=True,
+        name=EvaluationMetricName.CONTEXT_RELEVANCY,
+    )
+
+    # Assert
+    assert config.score_to_label == {}
+    assert config.score_to_title == {}
+
+
+@pytest.mark.ai
+def test_evaluation_metric_config__serializes_to_dict__with_all_fields() -> None:
+    """
+    Purpose: Verify that config can be serialized to dictionary format.
+    Why this matters: Required for persistence and API serialization.
+    Setup summary: Create config with custom prompts, serialize, assert structure.
+    """
+    # Arrange
+    prompts_config: EvaluationMetricPromptsConfig = EvaluationMetricPromptsConfig(
+        system_prompt_template="System",
+        user_prompt_template="User",
+    )
+
+    # Act
+    config: EvaluationMetricConfig = EvaluationMetricConfig(
+        enabled=True,
+        name=EvaluationMetricName.CONTEXT_RELEVANCY,
+        prompts_config=prompts_config,
+    )
+    config_dict: dict = config.model_dump()
+
+    # Assert
+    assert "prompts_config" in config_dict
+    assert config_dict["prompts_config"]["system_prompt_template"] == "System"
+    assert config_dict["prompts_config"]["user_prompt_template"] == "User"