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

rasa/core/iam_credentials_providers/aws_iam_credentials_providers.py

@@ -0,0 +1,291 @@
+import os
+import threading
+import time
+from typing import Dict, Optional, Tuple
+from urllib.parse import ParseResult, urlencode, urlunparse
+
+import boto3
+import redis
+import structlog
+from aws_msk_iam_sasl_signer import MSKAuthTokenProvider
+from botocore.exceptions import BotoCoreError
+from botocore.model import ServiceId
+from botocore.session import get_session
+from botocore.signers import RequestSigner
+from cachetools import TTLCache, cached
+
+from rasa.core.constants import (
+    ELASTICACHE_REDIS_AWS_IAM_ENABLED_ENV_VAR_NAME,
+    KAFKA_MSK_AWS_IAM_ENABLED_ENV_VAR_NAME,
+    KAFKA_SERVICE_NAME,
+    RDS_SQL_DB_AWS_IAM_ENABLED_ENV_VAR_NAME,
+    REDIS_SERVICE_NAME,
+    SQL_SERVICE_NAME,
+)
+from rasa.core.iam_credentials_providers.credentials_provider_protocol import (
+    IAMCredentialsProvider,
+    IAMCredentialsProviderInput,
+    SupportedServiceType,
+    TemporaryCredentials,
+)
+from rasa.shared.exceptions import ConnectionException
+
+structlogger = structlog.get_logger(__name__)
+
+SERVICE_CONFIG: Dict[Tuple[SupportedServiceType, str], str] = {
+    (
+        SupportedServiceType.TRACKER_STORE,
+        SQL_SERVICE_NAME,
+    ): RDS_SQL_DB_AWS_IAM_ENABLED_ENV_VAR_NAME,
+    (
+        SupportedServiceType.TRACKER_STORE,
+        REDIS_SERVICE_NAME,
+    ): ELASTICACHE_REDIS_AWS_IAM_ENABLED_ENV_VAR_NAME,
+    (
+        SupportedServiceType.EVENT_BROKER,
+        KAFKA_SERVICE_NAME,
+    ): KAFKA_MSK_AWS_IAM_ENABLED_ENV_VAR_NAME,
+    (
+        SupportedServiceType.LOCK_STORE,
+        REDIS_SERVICE_NAME,
+    ): ELASTICACHE_REDIS_AWS_IAM_ENABLED_ENV_VAR_NAME,
+}
+
+
+class AWSRDSIAMCredentialsProvider(IAMCredentialsProvider):
+    """Generates temporary credentials for AWS RDS using IAM roles."""
+
+    def __init__(self, username: str, host: str, port: int) -> None:
+        """Initializes the provider."""
+        self.username = username
+        self.host = host
+        self.port = port
+
+    def get_temporary_credentials(self) -> TemporaryCredentials:
+        """Generates temporary credentials for AWS RDS."""
+        structlogger.debug(
+            "rasa.core.aws_rds_iam_credentials_provider.get_credentials",
+            event_info="IAM authentication for AWS RDS enabled. "
+            "Generating temporary auth token...",
+        )
+
+        try:
+            client = boto3.client("rds")
+            auth_token = client.generate_db_auth_token(
+                DBHostname=self.host,
+                Port=self.port,
+                DBUsername=self.username,
+            )
+            structlogger.info(
+                "rasa.core.aws_rds_iam_credentials_provider.generated_credentials",
+                event_info="Successfully generated temporary auth token for AWS RDS.",
+            )
+            return TemporaryCredentials(auth_token=auth_token)
+        except (BotoCoreError, ValueError) as exc:
+            structlogger.error(
+                "rasa.core.aws_rds_iam_credentials_provider.error_generating_credentials",
+                event_info="Failed to generate temporary auth token for AWS RDS.",
+                error=str(exc),
+            )
+            return TemporaryCredentials(auth_token=None)
+
+
+class AWSMSKafkaIAMCredentialsProvider(IAMCredentialsProvider):
+    """Generates temporary credentials for AWS MSK using IAM roles."""
+
+    def __init__(self) -> None:
+        self.region = os.getenv("AWS_DEFAULT_REGION", os.getenv("AWS_REGION"))
+        self._token: Optional[str] = None
+        self._expires_at: float = 0
+        self.refresh_margin_seconds = 60  # Refresh 60 seconds before expiry
+        # ensure thread safety when refreshing token because the
+        # kafka client library we use (confluent-kafka) is multithreaded
+        self.lock = threading.Lock()
+
+    @property
+    def token(self) -> Optional[str]:
+        return self._token
+
+    @token.setter
+    def token(self, value: str) -> None:
+        self._token = value
+
+    @property
+    def expires_at(self) -> float:
+        return self._expires_at
+
+    @expires_at.setter
+    def expires_at(self, value: float) -> None:
+        self._expires_at = value
+
+    def get_temporary_credentials(self) -> TemporaryCredentials:
+        """Generates temporary credentials for AWS MSK."""
+        with self.lock:
+            current_time = time.time()  # Current time in seconds
+            if (
+                not self.token
+                or current_time >= self.expires_at - self.refresh_margin_seconds
+            ):
+                try:
+                    auth_token, expiry_ms = MSKAuthTokenProvider.generate_auth_token(
+                        self.region
+                    )
+                    structlogger.debug(
+                        "rasa.core.aws_msk_iam_credentials_provider.get_credentials",
+                        event_info="Successfully generated AWS IAM token for "
+                        "Kafka authentication.",
+                    )
+                    self.token = auth_token
+                    self.expires_at = int(expiry_ms) / 1000  # Convert ms to seconds
+                    return TemporaryCredentials(
+                        auth_token=auth_token,
+                        expiration=self.expires_at,
+                    )
+                except Exception as exc:
+                    raise ConnectionException(
+                        f"Failed to generate AWS IAM token "
+                        f"for MSK authentication. Original exception: {exc}"
+                    ) from exc
+            else:
+                structlogger.debug(
+                    "rasa.core.aws_msk_iam_credentials_provider.get_credentials",
+                    event_info="Using cached AWS IAM token for Kafka authentication.",
+                )
+                return TemporaryCredentials(
+                    auth_token=self.token,
+                    expiration=self.expires_at,
+                )
+
+
+class AWSElasticacheRedisIAMCredentialsProvider(redis.CredentialProvider):
+    """Generates temporary credentials for AWS ElastiCache Redis using IAM roles."""
+
+    def __init__(self, username: str, cluster_name: Optional[str] = None) -> None:
+        """Initializes the provider."""
+        self.username = username
+        self.cluster_name = cluster_name
+        self.region = os.getenv("AWS_DEFAULT_REGION", os.getenv("AWS_REGION"))
+        self.session = get_session()
+        self.request_signer = RequestSigner(
+            ServiceId("elasticache"),
+            self.region,
+            "elasticache",
+            "v4",
+            self.session.get_credentials(),
+            self.session.get_component("event_emitter"),
+        )
+
+    # Generated IAM tokens are valid for 15 minutes
+    @cached(cache=TTLCache(maxsize=128, ttl=900))
+    def get_credentials(self) -> Tuple[str, str]:
+        """Generates temporary credentials for AWS ElastiCache Redis.
+
+        Required method implementation by redis-py CredentialProvider parent class.
+        Used internally by redis-py when connecting to Redis.
+        """
+        query_params = {"Action": "connect", "User": self.username}
+        url = urlunparse(
+            ParseResult(
+                scheme="https",
+                netloc=self.cluster_name,
+                path="/",
+                query=urlencode(query_params),
+                params="",
+                fragment="",
+            )
+        )
+        signed_url = self.request_signer.generate_presigned_url(
+            {"method": "GET", "url": url, "body": {}, "headers": {}, "context": {}},
+            operation_name="connect",
+            expires_in=900,
+            region_name=self.region,
+        )
+
+        # RequestSigner only seems to work if the URL has a protocol, but
+        # Elasticache only accepts the URL without a protocol
+        # So strip it off the signed URL before returning
+        return self.username, signed_url.removeprefix("https://")
+
+    def get_temporary_credentials(self) -> TemporaryCredentials:
+        """Generates temporary credentials for AWS ElastiCache Redis.
+
+        Implemented to comply with the IAMCredentialsProvider rasa-pro interface.
+        Calls the get_credentials method which is used internally by redis-py.
+        """
+        try:
+            username, signed_url = self.get_credentials()
+            structlogger.info(
+                "rasa.core.aws_elasticache_redis_iam_credentials_provider.generated_credentials",
+                event_info="Successfully generated temporary credentials for "
+                "AWS ElastiCache Redis.",
+            )
+            return TemporaryCredentials(username=username, presigned_url=signed_url)
+        except Exception as exc:
+            structlogger.error(
+                "rasa.core.aws_elasticache_redis_iam_credentials_provider.error_generating_credentials",
+                event_info="Failed to generate temporary credentials for "
+                "AWS ElastiCache Redis.",
+                error=str(exc),
+            )
+            return TemporaryCredentials()
+
+
+def is_iam_enabled(provider_input: "IAMCredentialsProviderInput") -> bool:
+    """Checks if IAM authentication is enabled for the given service."""
+    service_type = provider_input.service_type
+    service_name = provider_input.service_name
+    iam_enabled_env_var_name = SERVICE_CONFIG.get((service_type, service_name))
+
+    if not iam_enabled_env_var_name:
+        structlogger.warning(
+            "rasa.core.aws_iam_credentials_providers.is_iam_enabled.unsupported_service",
+            event_info=f"IAM authentication check requested for unsupported service: "
+            f"{service_name}",
+        )
+        return False
+
+    return os.getenv(iam_enabled_env_var_name, "false").lower() == "true"
+
+
+def create_aws_iam_credentials_provider(
+    provider_input: "IAMCredentialsProviderInput",
+) -> Optional["IAMCredentialsProvider"]:
+    """Factory function to create an AWS IAM credentials provider."""
+    iam_enabled = is_iam_enabled(provider_input)
+    if not iam_enabled:
+        structlogger.debug(
+            "rasa.core.aws_iam_credentials_providers.create_provider.iam_not_enabled",
+            event_info=f"IAM authentication not enabled for service: "
+            f"{provider_input.service_type}",
+        )
+        return None
+
+    if (
+        provider_input.service_type == SupportedServiceType.TRACKER_STORE
+        and provider_input.service_name == SQL_SERVICE_NAME
+    ):
+        return AWSRDSIAMCredentialsProvider(
+            username=provider_input.username,
+            host=provider_input.host,
+            port=provider_input.port,
+        )
+
+    if (
+        provider_input.service_type == SupportedServiceType.TRACKER_STORE
+        and provider_input.service_name == REDIS_SERVICE_NAME
+    ):
+        return AWSElasticacheRedisIAMCredentialsProvider(
+            username=provider_input.username,
+            cluster_name=provider_input.cluster_name,
+        )
+
+    if provider_input.service_type == SupportedServiceType.EVENT_BROKER:
+        return AWSMSKafkaIAMCredentialsProvider()
+
+    if provider_input.service_type == SupportedServiceType.LOCK_STORE:
+        return AWSElasticacheRedisIAMCredentialsProvider(
+            username=provider_input.username,
+            cluster_name=provider_input.cluster_name,
+        )
+
+    return None

rasa/core/iam_credentials_providers/credentials_provider_protocol.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+import os
+from enum import Enum
+from typing import Optional, Protocol, runtime_checkable
+
+import structlog
+from pydantic import BaseModel
+
+from rasa.core.constants import IAM_CLOUD_PROVIDER_ENV_VAR_NAME
+
+structlogger = structlog.get_logger(__name__)
+
+
+class TemporaryCredentials(BaseModel):
+    """Dataclass storing temporary credentials."""
+
+    auth_token: Optional[str] = None
+    expiration: Optional[float] = None
+    username: Optional[str] = None
+    presigned_url: Optional[str] = None
+
+
+@runtime_checkable
+class IAMCredentialsProvider(Protocol):
+    """Interface for generating temporary credentials using IAM roles."""
+
+    def get_temporary_credentials(self) -> TemporaryCredentials:
+        """Generates temporary credentials using IAM roles."""
+        ...
+
+
+class IAMCredentialsProviderType(Enum):
+    """Enum for supported IAM credentials provider types."""
+
+    AWS = "aws"
+
+
+class SupportedServiceType(Enum):
+    """Enum for supported services using IAM credentials providers."""
+
+    TRACKER_STORE = "tracker_store"
+    EVENT_BROKER = "event_broker"
+    LOCK_STORE = "lock_store"
+
+
+class IAMCredentialsProviderInput(BaseModel):
+    """Input data for creating an IAM credentials provider."""
+
+    service_type: SupportedServiceType
+    service_name: str
+    username: Optional[str] = None
+    host: Optional[str] = None
+    port: Optional[int] = None
+    cluster_name: Optional[str] = None
+
+
+def create_iam_credentials_provider(
+    provider_input: IAMCredentialsProviderInput,
+) -> Optional[IAMCredentialsProvider]:
+    """Factory function to create an IAM credentials provider.
+
+    Args:
+        provider_input: Input data for creating an IAM credentials provider.
+
+    Returns:
+        An instance of the specified IAM credentials provider or
+        None if the type is unsupported.
+    """
+    iam_cloud_provider = os.getenv(IAM_CLOUD_PROVIDER_ENV_VAR_NAME)
+
+    if iam_cloud_provider is None:
+        return None
+
+    try:
+        provider_type = IAMCredentialsProviderType(iam_cloud_provider.lower())
+    except ValueError:
+        structlogger.warning(
+            "rasa.core.iam_credentials_provider.create_iam_credentials_provider.unsupported_provider",
+            event_info=f"Unsupported IAM cloud provider: {iam_cloud_provider}",
+        )
+        return None
+
+    if provider_type == IAMCredentialsProviderType.AWS:
+        from rasa.core.iam_credentials_providers.aws_iam_credentials_providers import (
+            create_aws_iam_credentials_provider,
+        )
+
+        return create_aws_iam_credentials_provider(provider_input)
+
+    return None

rasa/core/lock_store.py

@@ -4,7 +4,7 @@ import asyncio
 import json
 import os
 from contextlib import asynccontextmanager
-from typing import Any, AsyncGenerator, Dict, Literal, Optional, Text, Union
+from typing import Any, AsyncGenerator, Dict, List, Literal, Optional, Text, Union
 
 import structlog
 from pydantic import (
@@ -12,12 +12,21 @@ from pydantic import (
     BaseModel,
     Field,
     NonNegativeInt,
+    ValidationError,
     model_validator,
 )
 
 import rasa.shared.utils.common
-from rasa.core.constants import DEFAULT_LOCK_LIFETIME
+from rasa.core.constants import DEFAULT_LOCK_LIFETIME, IAM_CLOUD_PROVIDER_ENV_VAR_NAME
+from rasa.core.iam_credentials_providers.credentials_provider_protocol import (
+    SupportedServiceType,
+)
 from rasa.core.lock import TicketLock
+from rasa.core.redis_connection_factory import (
+    DeploymentMode,
+    RedisConfig,
+    RedisConnectionFactory,
+)
 from rasa.shared.exceptions import ConnectionException, RasaException
 from rasa.shared.utils.io import raise_deprecation_warning
 from rasa.utils.endpoints import EndpointConfig
@@ -221,7 +230,7 @@ class LockStore:
 
 
 class RedisLockStoreConfig(BaseModel):
-    host: Union[AnyUrl, Literal["localhost"]] = Field(
+    host: Union[AnyUrl, Literal["localhost"], str] = Field(
         default="localhost", description="The host of the redis server."
     )
     port: NonNegativeInt = Field(
@@ -269,6 +278,18 @@ class RedisLockStoreConfig(BaseModel):
         "will be raised in case Redis doesn't respond "
         "within `socket_timeout` seconds.",
     )
+    deployment_mode: DeploymentMode = Field(
+        default=DeploymentMode.STANDARD,
+        description="Redis deployment mode: 'standard', 'cluster', or 'sentinel'",
+    )
+    endpoints: Optional[List[str]] = Field(
+        default=None,
+        description="List of endpoints for cluster/sentinel mode in 'host:port' format",
+    )
+    sentinel_service: Optional[str] = Field(
+        default=None,
+        description="Sentinel service name",
+    )
 
     @model_validator(mode="before")
     @classmethod
@@ -290,7 +311,9 @@ class RedisLockStoreConfig(BaseModel):
 
     @model_validator(mode="after")
     def verify_username_password(self) -> RedisLockStoreConfig:
-        if bool(self.username) ^ bool(self.password):
+        if os.getenv(IAM_CLOUD_PROVIDER_ENV_VAR_NAME) is None and (
+            bool(self.username) ^ bool(self.password)
+        ):
             raise ValueError(
                 f"Expected username and password. "
                 f"Found: username: {'<has value>' if self.username else '<N/A>'}, "
@@ -298,9 +321,6 @@ class RedisLockStoreConfig(BaseModel):
             )
         return self
 
-    def to_strict_redis(self) -> Dict[str, Any]:
-        return self.model_dump(by_alias=True, exclude={"key_prefix"})
-
 
 class RedisLockStore(LockStore):
     """Redis store for ticket locks."""
@@ -314,10 +334,27 @@ class RedisLockStore(LockStore):
         Args:
             config: Redis lock store configuration.
         """
-        import redis
-
         self.config = config
-        self.red = redis.StrictRedis(**self.config.to_strict_redis())
+        try:
+            redis_config = RedisConfig(
+                host=str(self.config.host),
+                port=self.config.port,
+                service_type=SupportedServiceType.LOCK_STORE,
+                db=self.config.db,
+                username=self.config.username,
+                password=self.config.password,
+                use_ssl=self.config.use_ssl,
+                ssl_keyfile=self.config.ssl_keyfile,
+                ssl_certfile=self.config.ssl_certfile,
+                ssl_ca_certs=self.config.ssl_ca_certs,
+                deployment_mode=self.config.deployment_mode.value,
+                endpoints=self.config.endpoints,
+                sentinel_service=self.config.sentinel_service,
+                socket_timeout=self.config.socket_timeout,
+            )
+            self.red = RedisConnectionFactory.create_connection(redis_config)
+        except ValidationError as e:
+            raise RasaException(f"Invalid Redis configuration: {e}")
 
         self.key_prefix = DEFAULT_REDIS_LOCK_STORE_KEY_PREFIX
         if self.config.key_prefix:
@@ -349,6 +386,9 @@ class RedisLockStore(LockStore):
         """Retrieves lock (see parent docstring for more information)."""
         serialised_lock = self.red.get(self.key_prefix + conversation_id)
         if serialised_lock:
+            # Handle bytes to string conversion for JSON parsing
+            if isinstance(serialised_lock, bytes):
+                serialised_lock = serialised_lock.decode("utf-8")
             return TicketLock.from_dict(json.loads(serialised_lock))
 
         return None

rasa/core/nlg/contextual_response_rephraser.py

@@ -317,14 +317,18 @@ class ContextualResponseRephraser(
             return response
 
         prompt_template_text = self._template_for_response_rephrasing(response)
+
+        # Last user message (=current input) should always be in prompt if available
         last_message_by_user = getattr(tracker.latest_message, "text", "")
         current_input = (
             f"{USER}: {last_message_by_user}" if last_message_by_user else ""
         )
 
+        # Only summarise conversation history if flagged
         if self.summarize_history:
             history = await self._create_history(tracker)
         else:
+            # Count multiple utterances by bot/user as single turn
             turns_wrapper = (
                 _count_multiple_utterances_as_single_turn
                 if self.count_multiple_utterances_as_single_turn
@@ -367,6 +371,7 @@ class ContextualResponseRephraser(
         )
 
         if not (llm_response and llm_response.choices and llm_response.choices[0]):
+            # If the LLM fails to generate a response, return the original response.
             return response
 
         updated_text = llm_response.choices[0]

rasa/core/nlg/generator.py

@@ -2,7 +2,6 @@ from typing import Any, Dict, List, Optional, Text, Union
 
 import structlog
 from jinja2 import Template
-from pypred import Predicate
 
 import rasa.shared.utils.common
 import rasa.shared.utils.io
@@ -12,6 +11,7 @@ from rasa.shared.constants import CHANNEL, RESPONSE_CONDITION
 from rasa.shared.core.domain import Domain
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.utils.endpoints import EndpointConfig
+from rasa.utils.pypred import Predicate
 
 structlogger = structlog.get_logger()
 

rasa/core/persistor.py

@@ -314,7 +314,7 @@ class AWSPersistor(Persistor):
             obj = self.s3.Object(self.bucket_name, model_path)
             return obj.content_length
         except Exception:
-            raise ModelNotFound()
+            raise ModelNotFound("Model not found")
 
     def _retrieve_tar(
         self, target_filename: str, target_path: Optional[str] = None
@@ -349,7 +349,7 @@ class AWSPersistor(Persistor):
                     target_filename=target_filename,
                     event_info=log,
                 )
-                raise ModelNotFound() from exc
+                raise ModelNotFound("Model not found") from exc
         except exceptions.BotoCoreError as exc:
             structlogger.error(
                 "aws_persistor.retrieve_tar.model_download_error",
@@ -357,7 +357,7 @@ class AWSPersistor(Persistor):
                 target_filename=target_filename,
                 event_info=log,
             )
-            raise ModelNotFound() from exc
+            raise ModelNotFound("Model not found") from exc
 
 
 class GCSPersistor(Persistor):
@@ -447,7 +447,7 @@ class GCSPersistor(Persistor):
             blob = self.bucket.blob(target_filename)
             return blob.size
         except Exception:
-            raise ModelNotFound()
+            raise ModelNotFound("Model not found")
 
     def _retrieve_tar(
         self, target_filename: str, target_path: Optional[str] = None
@@ -481,7 +481,7 @@ class GCSPersistor(Persistor):
                 target_filename=target_filename,
                 event_info=log,
             )
-            raise ModelNotFound() from exc
+            raise ModelNotFound("Model not found") from exc
 
 
 class AzurePersistor(Persistor):
@@ -534,7 +534,7 @@ class AzurePersistor(Persistor):
             properties = blob_client.get_blob_properties()
             return properties.size
         except Exception:
-            raise ModelNotFound()
+            raise ModelNotFound("Model not found")
 
     def _retrieve_tar(
         self, target_filename: Text, target_path: Optional[str] = None
@@ -570,4 +570,4 @@ class AzurePersistor(Persistor):
                 event_info=log,
                 exception=exc,
             )
-            raise ModelNotFound() from exc
+            raise ModelNotFound("Model not found") from exc

rasa/core/policies/enterprise_search_policy.py

@@ -12,7 +12,7 @@ from jinja2 import Template
 from pydantic import ValidationError
 
 import rasa.shared.utils.io
-from rasa.core.available_endpoints import AvailableEndpoints
+from rasa.core.config.available_endpoints import AvailableEndpoints
 from rasa.core.constants import (
     UTTER_SOURCE_METADATA_KEY,
 )
@@ -63,6 +63,8 @@ from rasa.shared.constants import (
 )
 from rasa.shared.core.constants import (
     ACTION_CANCEL_FLOW,
+    ACTION_METADATA_MESSAGE_KEY,
+    ACTION_METADATA_TEXT_KEY,
     ACTION_SEND_TEXT_NAME,
     DEFAULT_SLOT_NAMES,
 )
@@ -585,8 +587,8 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
             return self._create_prediction_internal_error(domain, tracker)
 
         action_metadata = {
-            "message": {
-                "text": response,
+            ACTION_METADATA_MESSAGE_KEY: {
+                ACTION_METADATA_TEXT_KEY: response,
                 SEARCH_RESULTS_METADATA_KEY: [
                     result.text for result in documents.results
                 ],
@@ -781,7 +783,7 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
         if not os.path.exists(docs_folder) or not os.path.isdir(docs_folder):
             error_message = (
                 f"Document source directory does not exist or is not a "
-                f"directory: '{docs_folder}'. "
+                f"directory: '{os.path.abspath(docs_folder)}'. "
                 "Please specify a valid path to the documents source directory in the "
                 "vector_store configuration."
             )
@@ -1130,8 +1132,7 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
         embeddings_config: Dict[Text, Any],
         log_source_method: str,
     ) -> None:
-        """
-        Perform the health checks using resolved LLM and embeddings configurations.
+        """Perform the health checks using resolved LLM and embeddings configurations.
         Resolved means the configuration is either:
         - A reference to a model group that has already been expanded into
           its corresponding configuration using the information from
@@ -1160,8 +1161,7 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
 
     @classmethod
     def get_system_default_prompt_based_on_config(cls, config: Dict[str, Any]) -> str:
-        """
-        Resolves the default prompt template for Enterprise Search Policy based on
+        """Resolves the default prompt template for Enterprise Search Policy based on
         the component's configuration.
 
         - The old prompt is selected when both citation and relevancy check are either
@@ -1192,8 +1192,7 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
         relevancy_check_enabled: bool,
         citation_enabled: bool,
     ) -> str:
-        """
-        Returns the appropriate default prompt template based on the feature flags.
+        """Returns the appropriate default prompt template based on the feature flags.
 
         The selection follows this priority:
         1. If relevancy check is enabled, return the prompt that includes both relevancy