rasa-pro 3.13.11__py3-none-any.whl → 3.14.0__py3-none-any.whl

rasa/shared/utils/common.py

@@ -17,6 +17,7 @@ from typing import (
     Optional,
     Sequence,
     Text,
+    Tuple,
     Type,
 )
 
@@ -102,9 +103,12 @@ def sort_list_of_dicts_by_first_key(dicts: List[Dict]) -> List[Dict]:
 
 def cached_method(f: Callable[..., Any]) -> Callable[..., Any]:
     """Caches method calls based on the call's `args` and `kwargs`.
+
     Works for `async` and `sync` methods. Don't apply this to functions.
+
     Args:
         f: The decorated method whose return value should be cached.
+
     Returns:
         The return value which the method gives for the first call with the given
         arguments.
@@ -358,6 +362,7 @@ def validate_environment(
     component_name: str,
 ) -> None:
     """Make sure all needed requirements for a component are met.
+
     Args:
          required_env_vars: List of environment variables that should be set
          required_packages: List of packages that should be installed
@@ -373,7 +378,8 @@ def validate_environment(
             importlib.import_module(p)
         except ImportError:
             raise MissingDependencyException(
-                f"Missing package for {component_name}: {p}"
+                f"Missing dependency for {component_name}: {p}. "
+                f"Please ensure the correct package is installed."
             )
 
 
@@ -388,3 +394,22 @@ Sign up at: https://feedback.rasa.com
 {separator}
 """
     print_success(message)
+
+
+def conditional_import(module_name: str, class_name: str) -> Tuple[Any, bool]:
+    """Conditionally import a class, returning (class, is_available) tuple.
+
+    Args:
+        module_name: The module path to import from
+        class_name: The class name to import
+
+    Returns:
+        A tuple of (class, is_available) where class is the imported class
+        or None if import failed, and is_available is a boolean indicating
+        whether the import was successful.
+    """
+    try:
+        module = __import__(module_name, fromlist=[class_name])
+        return getattr(module, class_name), True
+    except ImportError:
+        return None, False

rasa/shared/utils/health_check/health_check.py

@@ -1,7 +1,10 @@
 import os
-from typing import Any, Dict, Optional
+from typing import TYPE_CHECKING, Any, Dict, Optional
 
 from rasa.exceptions import HealthCheckError
+
+if TYPE_CHECKING:
+    pass
 from rasa.shared.constants import (
     LLM_API_HEALTH_CHECK_DEFAULT_VALUE,
     LLM_API_HEALTH_CHECK_ENV_VAR,
@@ -63,6 +66,7 @@ def perform_llm_health_check(
     log_source_component: str,
 ) -> None:
     """Try to instantiate the LLM Client to validate the provided config.
+
     If the LLM_API_HEALTH_CHECK environment variable is true, perform a test call
     to the LLM API. If config contains multiple models, perform a test call for each
     model in the model group.
@@ -125,6 +129,7 @@ def perform_embeddings_health_check(
     log_source_component: str,
 ) -> None:
     """Try to instantiate the Embedder to validate the provided config.
+
     If the LLM_API_HEALTH_CHECK environment variable is true, perform a test call
     to the Embeddings API. If config contains multiple models, perform a test call for
     each model in the model group.
@@ -240,8 +245,7 @@ def send_test_embeddings_api_request(
 
 
 def is_api_health_check_enabled() -> bool:
-    """Determines whether the API health check is enabled based on an environment
-    variable.
+    """Determines whether the API health check is enabled.
 
     Returns:
         bool: True if the API health check is enabled, False otherwise.

rasa/shared/utils/llm.py

@@ -23,13 +23,15 @@ from typing import (
 )
 
 import structlog
+from jinja2 import Environment, select_autoescape
 from pydantic import BaseModel, Field
 
 import rasa.cli.telemetry
 import rasa.cli.utils
 import rasa.shared.utils.cli
 import rasa.shared.utils.io
-from rasa.core.available_endpoints import AvailableEndpoints
+from rasa.core.config.available_endpoints import AvailableEndpoints
+from rasa.core.config.configuration import Configuration
 from rasa.shared.constants import (
     CONFIG_NAME_KEY,
     CONFIG_PIPELINE_KEY,
@@ -49,7 +51,15 @@ from rasa.shared.constants import (
     RASA_PATTERN_INTERNAL_ERROR_USER_INPUT_TOO_LONG,
     ROUTER_CONFIG_KEY,
 )
-from rasa.shared.core.events import BotUttered, UserUttered
+from rasa.shared.core.events import (
+    AgentCancelled,
+    AgentCompleted,
+    AgentInterrupted,
+    AgentResumed,
+    AgentStarted,
+    BotUttered,
+    UserUttered,
+)
 from rasa.shared.core.slots import BooleanSlot, CategoricalSlot, Slot
 from rasa.shared.engine.caching import get_local_cache_location
 from rasa.shared.exceptions import (
@@ -112,7 +122,7 @@ DEPLOYMENT_CENTRIC_PROVIDERS = [AZURE_OPENAI_PROVIDER]
 
 # Placeholder messages used in the transcript for
 # instances where user input results in an error
-ERROR_PLACEHOLDER = {
+ERROR_PLACEHOLDER: Dict[str, str] = {
     RASA_PATTERN_INTERNAL_ERROR_USER_INPUT_TOO_LONG: "[User sent really long message]",
     RASA_PATTERN_INTERNAL_ERROR_USER_INPUT_EMPTY: "",
     "default": "[User input triggered an error]",
@@ -225,6 +235,7 @@ def tracker_as_readable_transcript(
     ai_prefix: str = AI,
     max_turns: Optional[int] = 20,
     turns_wrapper: Optional[Callable[[List[str]], List[str]]] = None,
+    highlight_agent_turns: bool = False,
 ) -> str:
     """Creates a readable dialogue from a tracker.
 
@@ -234,6 +245,7 @@ def tracker_as_readable_transcript(
         ai_prefix: the prefix to use for ai utterances
         max_turns: the maximum number of turns to include in the transcript
         turns_wrapper: optional function to wrap the turns in a custom way
+        highlight_agent_turns: whether to highlight agent turns in the transcript
 
     Example:
         >>> tracker = Tracker(
@@ -251,7 +263,9 @@ def tracker_as_readable_transcript(
     Returns:
     A string representing the transcript of the tracker
     """
-    transcript = []
+    transcript: List[str] = []
+
+    current_ai_prefix = ai_prefix
 
     # using `applied_events` rather than `events` means that only events after the
     # most recent `Restart` or `SessionStarted` are included in the transcript
@@ -266,9 +280,20 @@ def tracker_as_readable_transcript(
             else:
                 message = sanitize_message_for_prompt(event.text)
             transcript.append(f"{human_prefix}: {message}")
-
         elif isinstance(event, BotUttered):
-            transcript.append(f"{ai_prefix}: {sanitize_message_for_prompt(event.text)}")
+            transcript.append(
+                f"{current_ai_prefix}: {sanitize_message_for_prompt(event.text)}"
+            )
+
+        if highlight_agent_turns:
+            if isinstance(event, AgentStarted) or isinstance(event, AgentResumed):
+                current_ai_prefix = event.agent_id
+            elif (
+                isinstance(event, AgentCompleted)
+                or isinstance(event, AgentCancelled)
+                or isinstance(event, AgentInterrupted)
+            ):
+                current_ai_prefix = ai_prefix
 
     # turns_wrapper to count multiple utterances by bot/user as single turn
     if turns_wrapper:
@@ -694,6 +719,38 @@ def embedder_client_factory(
     return client
 
 
+def validate_jinja2_template(template_content: Text) -> None:
+    """Validate that a template string has valid Jinja2 syntax.
+
+    Args:
+        template_content: The template content to validate
+
+    Raises:
+        jinja2.exceptions.TemplateSyntaxError: If the template has invalid syntax
+        Exception: If there's an error during validation
+    """
+    # Create environment with custom filters
+    env = Environment(
+        autoescape=select_autoescape(
+            disabled_extensions=["jinja2"],
+            default_for_string=False,
+            default=True,
+        )
+    )
+    # Register filters - lazy import to avoid circular dependencies
+    from rasa.dialogue_understanding.generator._jinja_filters import (
+        to_json_escaped_string,
+    )
+    from rasa.dialogue_understanding.generator.constants import (
+        TO_JSON_ESCAPED_STRING_JINJA_FILTER,
+    )
+
+    env.filters[TO_JSON_ESCAPED_STRING_JINJA_FILTER] = to_json_escaped_string
+
+    # Validate Jinja2 syntax
+    env.from_string(template_content)
+
+
 def get_prompt_template(
     jinja_file_path: Optional[Text],
     default_prompt_template: Text,
@@ -739,7 +796,7 @@ def get_prompt_template(
                 log_source_method=log_source_method,
             )
             return prompt_template
-    except (FileIOException, FileNotFoundException):
+    except (FileIOException, FileNotFoundException) as e:
         structlogger.warning(
             "utils.llm.get_prompt_template" ".failed_to_read_custom_prompt_template",
             event_info=(
@@ -747,6 +804,7 @@ def get_prompt_template(
             ),
             log_source_component=log_source_component,
             log_source_method=log_source_method,
+            error=str(e),
         )
     return default_prompt_template
 
@@ -899,7 +957,7 @@ def resolve_model_client_config(
     if model_groups:
         endpoints = AvailableEndpoints(model_groups=model_groups)
     else:
-        endpoints = AvailableEndpoints.get_instance()
+        endpoints = Configuration.get_instance().endpoints
     if endpoints.model_groups is None:
         _raise_invalid_config_exception(
             reason=(
@@ -1015,26 +1073,24 @@ def _get_llm_command_generator_config(
     return None
 
 
-def _get_command_generator_prompt(
-    config: Dict[Text, Any], endpoints: Dict[Text, Any]
+def _get_compact_llm_command_generator_prompt(
+    config: Dict[Text, Any], model_groups: Dict[Text, Any]
 ) -> Text:
     """Get the command generator prompt based on the config."""
     from rasa.dialogue_understanding.generator.single_step.compact_llm_command_generator import (  # noqa: E501
-        DEFAULT_COMMAND_PROMPT_TEMPLATE_FILE_NAME,
-        FALLBACK_COMMAND_PROMPT_TEMPLATE_FILE_NAME,
-        MODEL_PROMPT_MAPPER,
+        CompactLLMCommandGenerator,
     )
 
     model_config = _get_llm_command_generator_config(config)
     llm_config = resolve_model_client_config(
         model_config=model_config,
-        model_groups=endpoints.get(MODEL_GROUPS_CONFIG_KEY),
+        model_groups=model_groups,
     )
     return get_default_prompt_template_based_on_model(
         llm_config=llm_config or {},
-        model_prompt_mapping=MODEL_PROMPT_MAPPER,
-        default_prompt_path=DEFAULT_COMMAND_PROMPT_TEMPLATE_FILE_NAME,
-        fallback_prompt_path=FALLBACK_COMMAND_PROMPT_TEMPLATE_FILE_NAME,
+        model_prompt_mapping=CompactLLMCommandGenerator.get_model_prompt_mapper(),
+        default_prompt_path=CompactLLMCommandGenerator.get_default_prompt_template_file_name(),
+        fallback_prompt_path=CompactLLMCommandGenerator.get_fallback_prompt_template_file_name(),
     )
 
 
@@ -1063,7 +1119,7 @@ def get_system_default_prompts(
 
     Args:
         config: The config.yml file data.
-        endpoints: The endpoints.yml file data.
+        endpoints: The endpoints configuration dictionary.
 
     Returns:
         SystemPrompts: A Pydantic model containing all default prompts.
@@ -1072,8 +1128,25 @@ def get_system_default_prompts(
         DEFAULT_RESPONSE_VARIATION_PROMPT_TEMPLATE,
     )
 
+    # The Model Manager / Model API service receives the endpoints configuration
+    # as raw YAML text rather than as a file path. However, both
+    # Configuration.initialise_endpoints() and AvailableEndpoints.read_endpoints()
+    # currently only accept a Path input and do not support loading from in-memory
+    # YAML content.
+
+    # Since these classes only support file-based initialization today, we need
+    # to bootstrap the Configuration with an empty AvailableEndpoints instance for now.
+
+    # IMPORTANT: This configuration must be properly initialized with valid endpoints
+    # and available agents once Studio introduces full support for Agent configurations
+    # (A2A and MCP).
+    Configuration.initialise_empty()
+
+    model_groups = endpoints.get(MODEL_GROUPS_CONFIG_KEY)
     return SystemPrompts(
-        command_generator=_get_command_generator_prompt(config, endpoints),
+        command_generator=_get_compact_llm_command_generator_prompt(
+            config, model_groups
+        ),
         enterprise_search=_get_enterprise_search_prompt(config),
         contextual_response_rephraser=DEFAULT_RESPONSE_VARIATION_PROMPT_TEMPLATE,
     )

rasa/shared/utils/mcp/server_connection.py

@@ -0,0 +1,250 @@
+"""MCP server connection utilities."""
+
+import asyncio
+import warnings
+from contextlib import AsyncExitStack, asynccontextmanager
+from typing import Any, AsyncIterator, ClassVar, Dict, List, Optional
+
+import structlog
+from httpx import HTTPStatusError
+from mcp import ClientSession
+from mcp.client.streamable_http import streamablehttp_client
+
+from rasa.shared.agents.auth.agent_auth_manager import AgentAuthManager
+from rasa.shared.agents.auth.auth_strategy import AgentAuthStrategy
+from rasa.shared.exceptions import AuthenticationError
+
+structlogger = structlog.get_logger()
+
+
+# Suppress RuntimeWarning about unawaited coroutines when MCP server is not reachable.
+warnings.filterwarnings(
+    "ignore",
+    message=".*BaseEventLoop.create_server.*was never awaited.*",
+    category=RuntimeWarning,
+)
+
+
+class MCPServerConnection:
+    """
+    Manages connection to an MCP server, with optional authentication.
+
+    This class handles:
+    - Connection establishment and cleanup
+    - Session lifecycle management
+    - Authentication via AgentAuthManager (API Key, OAuth2, mTLS, etc.)
+    """
+
+    # Timeout for ping operations in seconds
+    PING_TIMEOUT_SECONDS = 3.0
+
+    _SUPPORTED_SERVER_TYPES: ClassVar[List[str]] = ["http", "https"]
+
+    def __init__(
+        self,
+        server_name: str,
+        server_url: str,
+        server_type: str,
+        auth_manager: Optional[AgentAuthManager] = None,
+    ):
+        """
+        Initialize the MCP server connection.
+
+        Args:
+            server_name: Server name to identify the server
+            server_url: Server URL
+            server_type: Server type (currently only 'http' is supported)
+            auth_manager: Optional AgentAuthManager instance for this connection
+        """
+        self.server_name = server_name
+        self.server_url = server_url
+        self.server_type = server_type
+        self._auth_manager = auth_manager
+        self.session: Optional[ClientSession] = None
+        self.exit_stack: Optional[AsyncExitStack] = None
+
+    @classmethod
+    def from_config(cls, server_config: Dict[str, Any]) -> "MCPServerConnection":
+        """Initialize the MCP server connection from a configuration dictionary."""
+        auth_config = server_config.get("additional_params")
+        _auth_manager = AgentAuthManager.load_auth(auth_config)
+        return cls(
+            server_config["name"],
+            server_config["url"],
+            server_config.get("type", "http"),
+            _auth_manager,
+        )
+
+    @staticmethod
+    @asynccontextmanager
+    async def open_mcp_session(
+        url: str, auth_strategy: Optional[AgentAuthStrategy] = None
+    ) -> AsyncIterator[ClientSession]:
+        """
+        Open a streamable MCP session, ensuring that initialization
+        completes before yielding.
+        """
+        async with streamablehttp_client(url, auth=auth_strategy) as (
+            read_stream,
+            write_stream,
+            _,
+        ):
+            async with ClientSession(read_stream, write_stream) as session:
+                await session.initialize()  # handshake done here
+                yield session
+
+    async def connect(self) -> None:
+        """Establish connection to the MCP server.
+
+        Raises:
+            ValueError: If the server type is not supported.
+            ConnectionError: If connection fails.
+            AuthenticationError: If authentication fails.
+        """
+        if self.server_type not in self._SUPPORTED_SERVER_TYPES:
+            raise ValueError(f"Unsupported server type: {self.server_type}")
+
+        # Create a new exit stack for this connection to avoid task boundary issues
+        self.exit_stack = AsyncExitStack()
+
+        try:
+            # Get authentication strategy that adheres to httpx.Auth.
+            auth_strategy = (
+                self._auth_manager.get_auth() if self._auth_manager else None
+            )
+
+            # Register the wrapped context manager in the stack
+            self.session = await self.exit_stack.enter_async_context(
+                self.open_mcp_session(self.server_url, auth_strategy)
+            )
+
+        except Exception as eg:
+            for exc in getattr(eg, "exceptions", [eg]):
+                event_info = (
+                    f"Failed to connect to MCP server `{self.server_name}`. \nOriginal "
+                    f"error: {exc!s}"
+                )
+                if isinstance(exc, HTTPStatusError):
+                    status_code = exc.response.status_code
+                    structlogger.error(
+                        "mcp_server_connection.connect.http_status_error",
+                        event_info=event_info,
+                        server_name=self.server_name,
+                        server_url=self.server_url,
+                        status_code=status_code,
+                        response_text=exc.response.reason_phrase,
+                    )
+                    await self._cleanup()
+                    if status_code in [400, 401, 403]:
+                        raise AuthenticationError(str(exc)) from eg
+                    elif status_code == 404:
+                        raise Exception(str(exc)) from eg
+                    else:
+                        raise ConnectionError(str(exc)) from eg
+                else:
+                    structlogger.error(
+                        "mcp_server_connection.connect.other_exception",
+                        event_info=event_info,
+                        server_name=self.server_name,
+                        server_url=self.server_url,
+                        error=str(exc),
+                    )
+            await self._cleanup()
+            raise ConnectionError(str(exc)) from eg
+
+        except asyncio.CancelledError as e:
+            event_info = f"Connection to MCP server `{self.server_name}` was cancelled."
+            structlogger.error(
+                "mcp_server_connection.connect.connection_cancelled",
+                event_info=event_info,
+                server_name=self.server_name,
+                server_url=self.server_url,
+            )
+            # Clean up on cancellation
+            await self._cleanup()
+            raise ConnectionError(e) from e
+
+    async def ensure_active_session(self) -> ClientSession:
+        """
+        Ensure an active session is available.
+
+        If no session exists or the current session is inactive,
+        a new connection will be established.
+
+        Returns:
+            Active ClientSession instance.
+        """
+        if self.session is None:
+            await self.connect()
+            structlogger.info(
+                "mcp_server_connection.ensure_active_session.no_session",
+                server_name=self.server_name,
+                server_url=self.server_url,
+                event_info=(
+                    "No session found, connecting to the server "
+                    f"`{self.server_name}` @ `{self.server_url}`"
+                ),
+            )
+        if self.session:
+            try:
+                # Add timeout to prevent hanging when MCP server is down
+                await asyncio.wait_for(
+                    self.session.send_ping(), timeout=self.PING_TIMEOUT_SECONDS
+                )
+            except asyncio.TimeoutError as e:
+                structlogger.error(
+                    "mcp_server_connection.ensure_active_session.ping_timeout",
+                    server_name=self.server_name,
+                    server_url=self.server_url,
+                    event_info=(
+                        "Ping timed out, Server not reachable - "
+                        f"`{self.server_name}` @ `{self.server_url}`"
+                    ),
+                )
+                raise e
+            except Exception as e:
+                structlogger.warning(
+                    "mcp_server_connection.ensure_active_session.ping_failed",
+                    error=str(e),
+                    server_name=self.server_name,
+                    server_url=self.server_url,
+                    event_info=(
+                        "Ping failed, trying to reconnect to the server "
+                        f"`{self.server_name}` @ `{self.server_url}`"
+                    ),
+                )
+                # Cleanup existing session
+                await self.close()
+                # Attempt to reconnect now
+                await self.connect()
+                structlogger.info(
+                    "mcp_server_connection.ensure_active_session.reconnected",
+                    server_name=self.server_name,
+                    server_url=self.server_url,
+                    event_info=(
+                        "Reconnected to the server "
+                        f"`{self.server_name}` @ `{self.server_url}`"
+                    ),
+                )
+        assert self.session is not None  # Ensures type for mypy
+        return self.session
+
+    async def close(self) -> None:
+        """Close the connection and clean up resources."""
+        await self._cleanup()
+
+    async def _cleanup(self) -> None:
+        """Internal cleanup method to safely close resources."""
+        if self.exit_stack:
+            try:
+                await self.exit_stack.aclose()
+            except Exception as e:
+                # Log cleanup errors but don't raise them
+                structlogger.warning(
+                    "mcp_server_connection.cleanup.failed",
+                    server_name=self.server_name,
+                    error=str(e),
+                )
+            finally:
+                self.exit_stack = None
+                self.session = None

rasa/shared/utils/mcp/utils.py

@@ -0,0 +1,20 @@
+"""MCP utilities."""
+
+
+def mcp_server_exists(mcp_server: str) -> bool:
+    """Check if an MCP server exists in the configured endpoints.
+
+    Args:
+        mcp_server: The name of the MCP server to check.
+
+    Returns:
+        True if the MCP server exists, False otherwise.
+    """
+    from rasa.core.config.configuration import Configuration
+
+    endpoints = Configuration.get_instance().endpoints
+    if (mcp_server_list := endpoints.mcp_servers) is None:
+        return False
+
+    mcp_server_names = [server.name for server in mcp_server_list]
+    return mcp_server in mcp_server_names

rasa/shared/utils/schemas/events.py

@@ -160,6 +160,43 @@ FLOW_CANCELLED = {
         "step_id": {"type": "string"},
     }
 }
+AGENT_STARTED = {
+    "properties": {
+        "event": {"const": "agent_started"},
+        "agent_id": {"type": "string"},
+        "flow_id": {"type": "string"},
+    }
+}
+AGENT_COMPLETED = {
+    "properties": {
+        "event": {"const": "agent_completed"},
+        "agent_id": {"type": "string"},
+        "flow_id": {"type": "string"},
+        "status": {"type": "string"},
+    }
+}
+AGENT_INTERRUPTED = {
+    "properties": {
+        "event": {"const": "agent_interrupted"},
+        "agent_id": {"type": "string"},
+        "flow_id": {"type": "string"},
+    }
+}
+AGENT_RESUMED = {
+    "properties": {
+        "event": {"const": "agent_resumed"},
+        "agent_id": {"type": "string"},
+        "flow_id": {"type": "string"},
+    }
+}
+AGENT_CANCELLED = {
+    "properties": {
+        "event": {"const": "agent_cancelled"},
+        "agent_id": {"type": "string"},
+        "flow_id": {"type": "string"},
+        "reason": {"type": "string"},
+    }
+}
 DIALOGUE_STACK_UPDATED = {
     "properties": {"event": {"const": "stack"}, "update": {"type": "string"}}
 }
@@ -204,6 +241,11 @@ EVENT_SCHEMA = {
         FLOW_RESUMED,
         FLOW_COMPLETED,
         FLOW_CANCELLED,
+        AGENT_STARTED,
+        AGENT_COMPLETED,
+        AGENT_INTERRUPTED,
+        AGENT_RESUMED,
+        AGENT_CANCELLED,
         DIALOGUE_STACK_UPDATED,
         ROUTING_SESSION_ENDED,
         SESSION_ENDED,

rasa/shared/utils/yaml.py

@@ -335,7 +335,9 @@ class YamlValidationException(YamlException, ValueError):
                     )
                     if found_lc:
                         return line_offset
-                    return this_line + line_offset
+                    if this_line is not None:
+                        return this_line + line_offset
+                    return line_offset
                 return line
             elif isinstance(current, list) and head.isdigit():
                 return (

rasa/studio/download.py

@@ -10,6 +10,7 @@ from ruamel.yaml.scalarstring import LiteralScalarString
 
 import rasa.cli.utils
 import rasa.shared.utils.cli
+from rasa.core.config.configuration import Configuration
 from rasa.shared.constants import (
     DEFAULT_CONFIG_PATH,
     DEFAULT_DATA_PATH,
@@ -116,6 +117,8 @@ def _handle_endpoints(handler: StudioDataHandler, root: Path) -> None:
     endpoints_path = root / DEFAULT_ENDPOINTS_PATH
     endpoints_path.write_text(endpoints_data, encoding="utf-8")
 
+    Configuration.initialise_endpoints(endpoints_path=endpoints_path)
+
 
 def _handle_domain(handler: StudioDataHandler, root: Path) -> None:
     """Persist the assistant’s domain file.

rasa/studio/prompts.py

@@ -43,6 +43,7 @@ def handle_prompts(prompts: Dict[Text, Text], root: Path) -> None:
     config: Dict = read_yaml(config_path)
     endpoints: Dict = read_yaml(endpoints_path)
 
+    # System default prompts are dependent on the endpoints
     system_prompts = get_system_default_prompts(config, endpoints)
 
     _handle_contextual_response_rephraser(