rasa-pro 3.13.0.dev20250612__py3-none-any.whl → 3.13.0.dev20250613__py3-none-any.whl

rasa/shared/core/events.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import abc
 import copy
 import json
@@ -6,7 +8,7 @@ import re
 import time
 import uuid
 from abc import ABC
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -453,6 +455,7 @@ class UserUttered(Event):
         message_id: Optional[Text] = None,
         metadata: Optional[Dict] = None,
         use_text_for_featurization: Optional[bool] = None,
+        anonymized_at: Optional[float] = None,
     ) -> None:
         """Creates event for incoming user message.
 
@@ -467,6 +470,7 @@ class UserUttered(Event):
             message_id: Unique ID for message.
             use_text_for_featurization: `True` if the message's text was used to predict
                 next action. `False` if the message's intent was used.
+            anonymized_at: When the event was anonymized in the tracker store.
 
         """
         self.text = text
@@ -500,7 +504,11 @@ class UserUttered(Event):
         if parse_data:
             self.parse_data.update(**parse_data)
 
-        self._anonymized_at: Optional[datetime] = None
+        self._anonymized_at: Optional[datetime] = (
+            datetime.fromtimestamp(anonymized_at, tz=timezone.utc)
+            if anonymized_at is not None
+            else None
+        )
 
     @property
     def anonymized_at(self) -> Optional[datetime]:
@@ -525,6 +533,7 @@ class UserUttered(Event):
         input_channel: Optional[Text] = None,
         message_id: Optional[Text] = None,
         metadata: Optional[Dict] = None,
+        anonymized_at: Optional[float] = None,
     ) -> "UserUttered":
         return UserUttered(
             text,
@@ -535,6 +544,7 @@ class UserUttered(Event):
             input_channel,
             message_id,
             metadata,
+            anonymized_at,
         )
 
     def __hash__(self) -> int:
@@ -633,7 +643,9 @@ class UserUttered(Event):
                 "input_channel": getattr(self, "input_channel", None),
                 "message_id": getattr(self, "message_id", None),
                 "metadata": self.metadata,
-                "anonymized_at": self.anonymized_at,
+                "anonymized_at": self.anonymized_at.timestamp()
+                if self.anonymized_at
+                else None,
             }
         )
         return _dict
@@ -693,6 +705,7 @@ class UserUttered(Event):
                     parameters.get("input_channel"),
                     parameters.get("message_id"),
                     parameters.get("metadata"),
+                    parameters.get("anonymized_at"),
                 )
             ]
         except KeyError as e:
@@ -920,6 +933,7 @@ class BotUttered(SkipEventInMDStoryMixin):
         data: Optional[Dict] = None,
         metadata: Optional[Dict[Text, Any]] = None,
         timestamp: Optional[float] = None,
+        anonymized_at: Optional[float] = None,
     ) -> None:
         """Creates event for a bot response.
 
@@ -928,10 +942,15 @@ class BotUttered(SkipEventInMDStoryMixin):
             data: Additional data for more complex utterances (e.g. buttons).
             timestamp: When the event was created.
             metadata: Additional event metadata.
+            anonymized_at: When the event was anonymized in the tracker store.
         """
         self.text = text
         self.data = data or {}
-        self._anonymized_at: Optional[datetime] = None
+        self._anonymized_at: Optional[datetime] = (
+            datetime.fromtimestamp(anonymized_at, tz=timezone.utc)
+            if anonymized_at is not None
+            else None
+        )
         super().__init__(timestamp, metadata)
 
     @property
@@ -1040,7 +1059,9 @@ class BotUttered(SkipEventInMDStoryMixin):
                 "text": self.text,
                 "data": self.data,
                 "metadata": self.metadata,
-                "anonymized_at": self.anonymized_at,
+                "anonymized_at": self.anonymized_at.timestamp()
+                if self.anonymized_at
+                else None,
             }
         )
         return d
@@ -1053,6 +1074,7 @@ class BotUttered(SkipEventInMDStoryMixin):
                 parameters.get("data"),
                 parameters.get("metadata"),
                 parameters.get("timestamp"),
+                parameters.get("anonymized_at"),
             )
         except KeyError as e:
             raise ValueError(f"Failed to parse bot uttered event. {e}")
@@ -1077,6 +1099,7 @@ class SlotSet(Event):
         timestamp: Optional[float] = None,
         metadata: Optional[Dict[Text, Any]] = None,
         filled_by: Optional[str] = None,
+        anonymized_at: Optional[float] = None,
     ) -> None:
         """Creates event to set slot.
 
@@ -1089,7 +1112,11 @@ class SlotSet(Event):
         self.key = key
         self.value = value
         self._filled_by = filled_by
-        self._anonymized_at: Optional[datetime] = None
+        self._anonymized_at: Optional[datetime] = (
+            datetime.fromtimestamp(anonymized_at, tz=timezone.utc)
+            if anonymized_at is not None
+            else None
+        )
         super().__init__(timestamp, metadata)
 
     @property
@@ -1156,7 +1183,9 @@ class SlotSet(Event):
                 "name": self.key,
                 "value": self.value,
                 "filled_by": self.filled_by,
-                "anonymized_at": self.anonymized_at,
+                "anonymized_at": self.anonymized_at.timestamp()
+                if self.anonymized_at
+                else None,
             }
         )
         return d
@@ -1170,6 +1199,7 @@ class SlotSet(Event):
                 parameters.get("timestamp"),
                 parameters.get("metadata"),
                 filled_by=parameters.get("filled_by"),
+                anonymized_at=parameters.get("anonymized_at"),
             )
         except KeyError as e:
             raise ValueError(f"Failed to parse set slot event. {e}")

rasa/shared/core/flows/flow.py

@@ -406,8 +406,7 @@ class Flow:
             structlogger.error(
                 "command_generator.validate_flow_starting_conditions.error",
                 predicate=self.guard_condition,
-                context=context,
-                slots=slots,
+                flow_id=self.id,
                 error=str(e),
             )
             return False

rasa/shared/core/flows/flows_yaml_schema.json

@@ -244,6 +244,9 @@
                                         }
                                     }
                                 }
+                            },
+                            "silence_timeout": {
+                                "type": "number"
                             }
                         }
                     }

rasa/shared/core/flows/steps/collect.py

@@ -1,16 +1,23 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Any, Dict, List, Set, Text
+from typing import Any, Dict, List, Optional, Set, Text, Union
+
+import structlog
 
 from rasa.shared.constants import ACTION_ASK_PREFIX, UTTER_ASK_PREFIX
 from rasa.shared.core.flows.flow_step import FlowStep
 from rasa.shared.core.slots import SlotRejection
+from rasa.shared.exceptions import RasaException
 
 DEFAULT_ASK_BEFORE_FILLING = False
 DEFAULT_RESET_AFTER_FLOW_ENDS = True
 DEFAULT_FORCE_SLOT_FILLING = False
 
+logger = structlog.get_logger(__name__)
+
+SilenceTimeoutInstructionType = Union[int, float, Dict[str, Any]]
+
 
 @dataclass
 class CollectInformationFlowStep(FlowStep):
@@ -30,6 +37,8 @@ class CollectInformationFlowStep(FlowStep):
     """Whether to reset the slot value at the end of the flow."""
     force_slot_filling: bool = False
     """Whether to keep only the SetSlot command for the collected slot."""
+    silence_timeout: Optional[float] = None
+    """The silence timeout for the collect information step."""
 
     @classmethod
     def from_json(
@@ -44,6 +53,11 @@ class CollectInformationFlowStep(FlowStep):
         Returns:
             A CollectInformationFlowStep object
         """
+
+        silence_timeout = cls._deserialise_silence_timeout(
+            data.get("silence_timeout", None)
+        )
+
         base = super().from_json(flow_id, data)
         return CollectInformationFlowStep(
             collect=data["collect"],
@@ -58,14 +72,40 @@ class CollectInformationFlowStep(FlowStep):
                 for rejection in data.get("rejections", [])
             ],
             force_slot_filling=data.get("force_slot_filling", False),
+            silence_timeout=silence_timeout,
             **base.__dict__,
         )
 
+    @staticmethod
+    def _deserialise_silence_timeout(
+        silence_timeout_json: Optional[SilenceTimeoutInstructionType],
+    ) -> Optional[float]:
+        """Deserialize silence timeout from JSON."""
+        if not silence_timeout_json:
+            return None
+
+        if not isinstance(silence_timeout_json, (int, float)):
+            raise RasaException(
+                f"Invalid silence timeout value: {silence_timeout_json}. "
+                "If defined at collect step, silence timeout must be a number."
+            )
+
+        silence_timeout = silence_timeout_json
+
+        if silence_timeout and silence_timeout < 0:
+            raise RasaException(
+                f"Invalid silence timeout value: {silence_timeout}. "
+                "Silence timeout must be a non-negative number."
+            )
+        return silence_timeout
+
     @staticmethod
     def _default_utter(collect: str) -> str:
         return f"{UTTER_ASK_PREFIX}{collect}"
 
-    def as_json(self) -> Dict[str, Any]:  # type: ignore[override]
+    def as_json(
+        self, step_properties: Optional[Dict[Text, Any]] = None
+    ) -> Dict[str, Any]:
         """Serialize the CollectInformationFlowStep object.
 
         Returns:
@@ -78,6 +118,9 @@ class CollectInformationFlowStep(FlowStep):
         data["reset_after_flow_ends"] = self.reset_after_flow_ends
         data["rejections"] = [rejection.as_dict() for rejection in self.rejections]
         data["force_slot_filling"] = self.force_slot_filling
+        if self.silence_timeout:
+            data["silence_timeout"] = self.silence_timeout
+
         return super().as_json(step_properties=data)
 
     @property
@@ -100,6 +143,7 @@ class CollectInformationFlowStep(FlowStep):
                 and self.ask_before_filling == other.ask_before_filling
                 and self.reset_after_flow_ends == other.reset_after_flow_ends
                 and self.force_slot_filling == other.force_slot_filling
+                and self.silence_timeout == other.silence_timeout
                 and super().__eq__(other)
             )
         return False

rasa/shared/core/slots.py

@@ -311,6 +311,34 @@ class Slot(ABC):
         """Indicates if the slot requires validation."""
         return True if self.validation else False
 
+    def to_dict(
+        self,
+        *,
+        include_private: bool = False,
+    ) -> Dict[str, Any]:
+        """Return a dictionary with attributes of this slot instance.
+
+        Args:
+            include_private: If `True`, private attributes are included.
+
+        Returns:
+            A plain `dict` that can be JSON-serialised.
+        """
+        result: Dict[str, Any] = {}
+
+        for attr, value in vars(self).items():
+            if not include_private and attr.startswith("_"):
+                continue
+
+            if attr == "mappings":
+                result[attr] = [mapping.as_dict() for mapping in value]
+                continue
+
+            result[attr] = value
+
+        result.setdefault("type", self.type_name)
+        return result
+
 
 class FloatSlot(Slot):
     """A slot storing a float value."""

rasa/shared/exceptions.py

@@ -165,3 +165,7 @@ class ProviderClientAPIException(RasaException):
 
 class ProviderClientValidationError(RasaException):
     """Raised for errors that occur during validation of the API client."""
+
+
+class FinetuningDataPreparationException(RasaException):
+    """Raised when there is an error in data preparation for fine-tuning."""

rasa/shared/providers/_configs/azure_openai_client_config.py

@@ -23,6 +23,8 @@ from rasa.shared.constants import (
     DEPLOYMENT_NAME_CONFIG_KEY,
     ENGINE_CONFIG_KEY,
     LANGCHAIN_TYPE_CONFIG_KEY,
+    MAX_COMPLETION_TOKENS_CONFIG_KEY,
+    MAX_TOKENS_CONFIG_KEY,
     MODEL_CONFIG_KEY,
     MODEL_NAME_CONFIG_KEY,
     N_REPHRASES_CONFIG_KEY,
@@ -71,6 +73,8 @@ DEPRECATED_ALIASES_TO_STANDARD_KEY_MAPPING = {
     MODEL_NAME_CONFIG_KEY: MODEL_CONFIG_KEY,
     # Timeout aliases
     REQUEST_TIMEOUT_CONFIG_KEY: TIMEOUT_CONFIG_KEY,
+    # Max tokens aliases
+    MAX_TOKENS_CONFIG_KEY: MAX_COMPLETION_TOKENS_CONFIG_KEY,
 }
 
 REQUIRED_KEYS = [DEPLOYMENT_CONFIG_KEY]

rasa/shared/providers/_configs/openai_client_config.py

@@ -10,6 +10,8 @@ from rasa.shared.constants import (
     API_TYPE_CONFIG_KEY,
     API_VERSION_CONFIG_KEY,
     LANGCHAIN_TYPE_CONFIG_KEY,
+    MAX_COMPLETION_TOKENS_CONFIG_KEY,
+    MAX_TOKENS_CONFIG_KEY,
     MODEL_CONFIG_KEY,
     MODEL_NAME_CONFIG_KEY,
     N_REPHRASES_CONFIG_KEY,
@@ -48,6 +50,8 @@ DEPRECATED_ALIASES_TO_STANDARD_KEY_MAPPING = {
     OPENAI_API_VERSION_CONFIG_KEY: API_VERSION_CONFIG_KEY,
     # Timeout aliases
     REQUEST_TIMEOUT_CONFIG_KEY: TIMEOUT_CONFIG_KEY,
+    # Max tokens aliases
+    MAX_TOKENS_CONFIG_KEY: MAX_COMPLETION_TOKENS_CONFIG_KEY,
 }
 
 REQUIRED_KEYS = [MODEL_CONFIG_KEY]

rasa/shared/providers/embedding/_base_litellm_embedding_client.py

@@ -70,7 +70,10 @@ class _BaseLiteLLMEmbeddingClient:
     def _embedding_fn_args(self) -> Dict[str, Any]:
         """Returns the arguments to be passed to the embedding function."""
         return {
+            # Parameters set through config, can override drop_params
             **self._litellm_extra_parameters,
+            # Model name is constructed in the LiteLLM format from the provided config
+            # Non-overridable to ensure consistency
             "model": self._litellm_model_name,
         }
 

rasa/shared/providers/llm/_base_litellm_client.py

@@ -84,12 +84,15 @@ class _BaseLiteLLMClient:
     @property
     def _completion_fn_args(self) -> dict:
         return {
-            **self._litellm_extra_parameters,
-            "model": self._litellm_model_name,
             # Since all providers covered by LiteLLM use the OpenAI format, but
             # not all support every OpenAI parameter, raise an exception if
             # provider/model uses unsupported parameter
             "drop_params": False,
+            # All other parameters set through config, can override drop_params
+            **self._litellm_extra_parameters,
+            # Model name is constructed in the LiteLLM format from the provided config
+            # Non-overridable to ensure consistency
+            "model": self._litellm_model_name,
         }
 
     def validate_client_setup(self) -> None:

rasa/shared/utils/llm.py

@@ -1,13 +1,17 @@
+from __future__ import annotations
+
 import importlib.resources
 import json
 import logging
 from copy import deepcopy
+from datetime import datetime
 from functools import wraps
 from typing import (
     TYPE_CHECKING,
     Any,
     Callable,
     Dict,
+    List,
     Literal,
     Optional,
     Text,
@@ -18,14 +22,20 @@ from typing import (
 )
 
 import structlog
+from pydantic import BaseModel, Field
 
 import rasa.shared.utils.io
-from rasa.core.utils import AvailableEndpoints
+from rasa.core.available_endpoints import AvailableEndpoints
 from rasa.shared.constants import (
+    CONFIG_NAME_KEY,
+    CONFIG_PIPELINE_KEY,
+    CONFIG_POLICIES_KEY,
     DEFAULT_PROMPT_PACKAGE_NAME,
+    LLM_CONFIG_KEY,
     MODEL_CONFIG_KEY,
     MODEL_GROUP_CONFIG_KEY,
     MODEL_GROUP_ID_CONFIG_KEY,
+    MODEL_GROUPS_CONFIG_KEY,
     MODELS_CONFIG_KEY,
     PROVIDER_CONFIG_KEY,
     RASA_PATTERN_INTERNAL_ERROR_USER_INPUT_EMPTY,
@@ -61,9 +71,11 @@ from rasa.shared.providers.mappings import (
     get_embedding_client_from_provider,
     get_llm_client_from_provider,
 )
+from rasa.shared.utils.common import all_subclasses
 from rasa.shared.utils.constants import LOG_COMPONENT_SOURCE_METHOD_INIT
 
 if TYPE_CHECKING:
+    from rasa.core.agent import Agent
     from rasa.shared.core.trackers import DialogueStateTracker
 
 
@@ -107,6 +119,18 @@ _CombineConfigs_F = TypeVar(
 )
 
 
+class SystemPrompts(BaseModel):
+    command_generator: str = Field(
+        ..., description="Prompt used by the LLM command generator."
+    )
+    enterprise_search: str = Field(
+        ..., description="Prompt for standard enterprise search requests."
+    )
+    contextual_response_rephraser: str = Field(
+        ..., description="Prompt used for re-phrasing assistant responses."
+    )
+
+
 def _compute_hash_for_cache_from_configs(
     config_x: Dict[str, Any], config_y: Dict[str, Any]
 ) -> int:
@@ -191,6 +215,7 @@ def tracker_as_readable_transcript(
     human_prefix: str = USER,
     ai_prefix: str = AI,
     max_turns: Optional[int] = 20,
+    turns_wrapper: Optional[Callable[[List[str]], List[str]]] = None,
 ) -> str:
     """Creates a readable dialogue from a tracker.
 
@@ -199,6 +224,7 @@ def tracker_as_readable_transcript(
         human_prefix: the prefix to use for human utterances
         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
 
     Example:
         >>> tracker = Tracker(
@@ -235,8 +261,11 @@ def tracker_as_readable_transcript(
         elif isinstance(event, BotUttered):
             transcript.append(f"{ai_prefix}: {sanitize_message_for_prompt(event.text)}")
 
-    if max_turns:
-        transcript = transcript[-max_turns:]
+    # turns_wrapper to count multiple utterances by bot/user as single turn
+    if turns_wrapper:
+        transcript = turns_wrapper(transcript)
+    # otherwise, just take the last `max_turns` lines of the transcript
+    transcript = transcript[-max_turns if max_turns is not None else None :]
 
     return "\n".join(transcript)
 
@@ -678,7 +707,6 @@ def get_prompt_template(
     Returns:
         The prompt template.
     """
-
     try:
         if jinja_file_path is not None:
             prompt_template = rasa.shared.utils.io.read_file(jinja_file_path)
@@ -814,7 +842,9 @@ def allowed_values_for_slot(slot: Slot) -> Union[str, None]:
 
 
 def resolve_model_client_config(
-    model_config: Optional[Dict[str, Any]], component_name: Optional[str] = None
+    model_config: Optional[Dict[str, Any]],
+    component_name: Optional[str] = None,
+    model_groups: Optional[List[Dict[str, Any]]] = None,
 ) -> Optional[Dict[str, Any]]:
     """Resolve the model group in the model config.
 
@@ -828,6 +858,7 @@ def resolve_model_client_config(
         model_config: The model config to be resolved.
         component_name: The name of the component.
         component_name: The method of the component.
+        model_groups: Model groups from endpoints.yml.
 
     Returns:
         The resolved llm config.
@@ -854,7 +885,12 @@ def resolve_model_client_config(
 
     model_group_id = model_config.get(MODEL_GROUP_CONFIG_KEY)
 
-    endpoints = AvailableEndpoints.get_instance()
+    # If `model_groups` is provided, use it to initialise `AvailableEndpoints`,
+    # since `get_instance()` reads from the local endpoints file instead.
+    if model_groups:
+        endpoints = AvailableEndpoints(model_groups=model_groups)
+    else:
+        endpoints = AvailableEndpoints.get_instance()
     if endpoints.model_groups is None:
         _raise_invalid_config_exception(
             reason=(
@@ -886,3 +922,122 @@ def resolve_model_client_config(
         )
 
     return model_group[0]
+
+
+def generate_sender_id(test_case_name: str) -> str:
+    # add timestamp suffix to ensure sender_id is unique
+    return f"{test_case_name}_{datetime.now()}"
+
+
+async def create_tracker_for_user_step(
+    step_sender_id: str,
+    agent: "Agent",
+    test_case_tracker: "DialogueStateTracker",
+    index_user_uttered_event: int,
+) -> None:
+    """Creates a tracker for the user step."""
+    tracker = test_case_tracker.copy()
+    # modify the sender id so that the original tracker is not overwritten
+    tracker.sender_id = step_sender_id
+
+    if tracker.events:
+        # get the timestamp of the event just before the user uttered event
+        timestamp = tracker.events[index_user_uttered_event - 1].timestamp
+        # revert the tracker to the event just before the user uttered event
+        tracker = tracker.travel_back_in_time(timestamp)
+
+    # store the tracker with the unique sender id
+    await agent.tracker_store.save(tracker)
+
+
+def _get_llm_command_generator_config(
+    config: Dict[Text, Any],
+) -> Optional[Dict[Text, Any]]:
+    """Get the llm command generator config from config.yml.
+
+    Args:
+        config: The config.yml file data.
+
+    Returns:
+        The llm command generator config.
+    """
+    from rasa.dialogue_understanding.generator import LLMBasedCommandGenerator
+
+    # Collect all LLM based Command Generator class names.
+    command_generator_subclasses = all_subclasses(LLMBasedCommandGenerator)
+    command_generator_class_names = [
+        command_generator.__name__ for command_generator in command_generator_subclasses
+    ]
+
+    # Read the LLM config of the Command Generator from the config.yml file.
+    pipelines = config.get(CONFIG_PIPELINE_KEY, [])
+    for pipeline in pipelines:
+        if pipeline.get(CONFIG_NAME_KEY) in command_generator_class_names:
+            return pipeline.get(LLM_CONFIG_KEY)
+
+    return None
+
+
+def _get_command_generator_prompt(
+    config: Dict[Text, Any], endpoints: 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,
+    )
+
+    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),
+    )
+    return get_default_prompt_template_based_on_model(
+        llm_config=llm_config,
+        model_prompt_mapping=MODEL_PROMPT_MAPPER,
+        default_prompt_path=DEFAULT_COMMAND_PROMPT_TEMPLATE_FILE_NAME,
+        fallback_prompt_path=FALLBACK_COMMAND_PROMPT_TEMPLATE_FILE_NAME,
+    )
+
+
+def _get_enterprise_search_prompt(config: Dict[Text, Any]) -> Text:
+    """Get the enterprise search prompt based on the config."""
+    from rasa.core.policies.enterprise_search_policy import EnterpriseSearchPolicy
+
+    def get_enterprise_search_config() -> Dict[Text, Any]:
+        policies = config.get(CONFIG_POLICIES_KEY, [])
+        for policy in policies:
+            if policy.get(CONFIG_NAME_KEY) == EnterpriseSearchPolicy.__name__:
+                return policy
+
+        return {}
+
+    enterprise_search_config = get_enterprise_search_config()
+    return EnterpriseSearchPolicy.get_system_default_prompt_based_on_config(
+        enterprise_search_config
+    )
+
+
+def get_system_default_prompts(
+    config: Dict[Text, Any], endpoints: Dict[Text, Any]
+) -> SystemPrompts:
+    """
+    Returns the system default prompts for the component.
+
+    Args:
+        config: The config.yml file data.
+        endpoints: The endpoints.yml file data.
+
+    Returns:
+        SystemPrompts: A Pydantic model containing all default prompts.
+    """
+    from rasa.core.nlg.contextual_response_rephraser import (
+        DEFAULT_RESPONSE_VARIATION_PROMPT_TEMPLATE,
+    )
+
+    return SystemPrompts(
+        command_generator=_get_command_generator_prompt(config, endpoints),
+        enterprise_search=_get_enterprise_search_prompt(config),
+        contextual_response_rephraser=DEFAULT_RESPONSE_VARIATION_PROMPT_TEMPLATE,
+    )