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

rasa/core/policies/enterprise_search_policy_config.py

@@ -0,0 +1,241 @@
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass
+from typing import Any, Dict, List, Optional
+
+import structlog
+
+from rasa.core.constants import (
+    POLICY_MAX_HISTORY,
+    POLICY_PRIORITY,
+    SEARCH_POLICY_PRIORITY,
+)
+from rasa.shared.constants import (
+    EMBEDDINGS_CONFIG_KEY,
+    LLM_CONFIG_KEY,
+    MAX_COMPLETION_TOKENS_CONFIG_KEY,
+    MAX_RETRIES_CONFIG_KEY,
+    MODEL_CONFIG_KEY,
+    OPENAI_PROVIDER,
+    PROMPT_CONFIG_KEY,
+    PROMPT_TEMPLATE_CONFIG_KEY,
+    PROVIDER_CONFIG_KEY,
+    TEMPERATURE_CONFIG_KEY,
+    TIMEOUT_CONFIG_KEY,
+)
+from rasa.shared.utils.configs import (
+    raise_deprecation_warnings,
+    resolve_aliases,
+    validate_forbidden_keys,
+    validate_required_keys,
+)
+from rasa.shared.utils.llm import (
+    DEFAULT_ENTERPRISE_SEARCH_POLICY_MODEL_NAME,
+    DEFAULT_OPENAI_EMBEDDING_MODEL_NAME,
+    resolve_model_client_config,
+)
+
+structlogger = structlog.get_logger()
+
+
+SOURCE_PROPERTY = "source"
+VECTOR_STORE_TYPE_PROPERTY = "type"
+VECTOR_STORE_PROPERTY = "vector_store"
+VECTOR_STORE_THRESHOLD_PROPERTY = "threshold"
+TRACE_TOKENS_PROPERTY = "trace_prompt_tokens"
+CITATION_ENABLED_PROPERTY = "citation_enabled"
+USE_LLM_PROPERTY = "use_generative_llm"
+CHECK_RELEVANCY_PROPERTY = "check_relevancy"
+MAX_MESSAGES_IN_QUERY_KEY = "max_messages_in_query"
+
+DEFAULT_VECTOR_STORE_TYPE = "faiss"
+DEFAULT_VECTOR_STORE_THRESHOLD = 0.0
+DEFAULT_VECTOR_STORE = {
+    VECTOR_STORE_TYPE_PROPERTY: DEFAULT_VECTOR_STORE_TYPE,
+    SOURCE_PROPERTY: "./docs",
+    VECTOR_STORE_THRESHOLD_PROPERTY: DEFAULT_VECTOR_STORE_THRESHOLD,
+}
+
+DEFAULT_CHECK_RELEVANCY_PROPERTY = False
+DEFAULT_USE_LLM_PROPERTY = True
+DEFAULT_CITATION_ENABLED_PROPERTY = False
+DEFAULT_TRACE_PROMPT_TOKEN_PROPERTY = False
+
+DEFAULT_MAX_MESSAGES_IN_QUERY = 2
+
+DEFAULT_LLM_CONFIG = {
+    PROVIDER_CONFIG_KEY: OPENAI_PROVIDER,
+    MODEL_CONFIG_KEY: DEFAULT_ENTERPRISE_SEARCH_POLICY_MODEL_NAME,
+    TIMEOUT_CONFIG_KEY: 10,
+    TEMPERATURE_CONFIG_KEY: 0.0,
+    MAX_COMPLETION_TOKENS_CONFIG_KEY: 256,
+    MAX_RETRIES_CONFIG_KEY: 1,
+}
+
+DEFAULT_EMBEDDINGS_CONFIG = {
+    PROVIDER_CONFIG_KEY: OPENAI_PROVIDER,
+    MODEL_CONFIG_KEY: DEFAULT_OPENAI_EMBEDDING_MODEL_NAME,
+}
+
+DEFAULT_ENTERPRISE_SEARCH_CONFIG = {
+    POLICY_PRIORITY: SEARCH_POLICY_PRIORITY,
+    VECTOR_STORE_PROPERTY: DEFAULT_VECTOR_STORE,
+}
+
+REQUIRED_KEYS: List[str] = []
+
+FORBIDDEN_KEYS: List[str] = []
+
+DEPRECATED_ALIASES_TO_STANDARD_KEY_MAPPING = {
+    PROMPT_CONFIG_KEY: PROMPT_TEMPLATE_CONFIG_KEY
+}
+
+
+@dataclass
+class EnterpriseSearchPolicyConfig:
+    """Parses configuration for Enterprise Search Policy."""
+
+    # TODO: llm_config, embeddings_config, and vector_store_config should also be parsed
+    #   as "Config" objects. Likely part of a broader Rasa 4.0 rewrite where all
+    #   components rely on configuration parser. So, for example, llm_config and
+    #   embeddings_config should be parsed as ClientConfig objects, and
+    #   vector_store_config parsed as VectorStoreConfig object.
+    llm_config: dict
+    embeddings_config: dict
+    vector_store_config: dict
+
+    prompt_template: str
+
+    use_generative_llm: bool = DEFAULT_USE_LLM_PROPERTY
+    enable_citation: bool = DEFAULT_CITATION_ENABLED_PROPERTY
+    check_relevancy: bool = DEFAULT_CHECK_RELEVANCY_PROPERTY
+
+    max_history: Optional[int] = None
+    max_messages_in_query: int = DEFAULT_MAX_MESSAGES_IN_QUERY
+    trace_prompt_tokens: bool = DEFAULT_TRACE_PROMPT_TOKEN_PROPERTY
+
+    @property
+    def vector_store_type(self) -> str:
+        # TODO: In the future this should ideally be part of the Vector config
+        #       and not the property of the EnterpriseSearch config
+        return (
+            self.vector_store_config.get(VECTOR_STORE_TYPE_PROPERTY)
+            or DEFAULT_VECTOR_STORE_TYPE
+        )
+
+    @property
+    def vector_store_threshold(self) -> float:
+        # TODO: In the future this should ideally be part of the Vector config
+        #       and not the property of the EnterpriseSearch config
+        return (
+            self.vector_store_config.get(VECTOR_STORE_THRESHOLD_PROPERTY)
+            or DEFAULT_VECTOR_STORE_THRESHOLD
+        )
+
+    @property
+    def vector_store_source(self) -> Optional[str]:
+        # TODO: In the future this should ideally be part of the Vector config
+        #       and not the property of the EnterpriseSearch config
+        return self.vector_store_config.get(SOURCE_PROPERTY)
+
+    def __post_init__(self) -> None:
+        if self.check_relevancy and not self.use_generative_llm:
+            structlogger.warning(
+                "enterprise_search_policy"
+                ".relevancy_check_enabled_with_disabled_generative_search",
+                event_info=(
+                    f"The config parameter '{CHECK_RELEVANCY_PROPERTY}' is set to"
+                    f"'True', but the generative search is disabled (config"
+                    f"parameter '{USE_LLM_PROPERTY}' is set to 'False'). As a result, "
+                    "the relevancy check for the generative search will be disabled. "
+                    f"To use this check, set the config parameter '{USE_LLM_PROPERTY}' "
+                    f"to `True`."
+                ),
+            )
+        if self.enable_citation and not self.use_generative_llm:
+            structlogger.warning(
+                "enterprise_search_policy"
+                ".citation_enabled_with_disabled_generative_search",
+                event_info=(
+                    f"The config parameter '{CITATION_ENABLED_PROPERTY}' is set to"
+                    f"'True', but the generative search is disabled (config"
+                    f"parameter '{USE_LLM_PROPERTY}' is set to 'False'). As a result, "
+                    "the citation for the generative search will be disabled. "
+                    f"To use this check, set the config parameter '{USE_LLM_PROPERTY}' "
+                    f"to `True`."
+                ),
+            )
+
+    @classmethod
+    def from_dict(cls, config: dict) -> EnterpriseSearchPolicyConfig:
+        """Initializes a dataclass from the passed config.
+
+        Args:
+            config: (dict) The config from which to initialize.
+
+        Raises:
+            ValueError: Config is missing required keys.
+
+        Returns:
+            AzureOpenAIClientConfig
+        """
+        # Resolve LLM config
+        llm_config = (
+            resolve_model_client_config(
+                config.get(LLM_CONFIG_KEY), EnterpriseSearchPolicyConfig.__name__
+            )
+            or DEFAULT_LLM_CONFIG
+        )
+
+        # Resolve embeddings config
+        embeddings_config = (
+            resolve_model_client_config(
+                config.get(EMBEDDINGS_CONFIG_KEY), EnterpriseSearchPolicyConfig.__name__
+            )
+            or DEFAULT_EMBEDDINGS_CONFIG
+        )
+
+        # Vector store config
+        vector_store_config = config.get(VECTOR_STORE_PROPERTY, DEFAULT_VECTOR_STORE)
+
+        # Check for deprecated keys
+        raise_deprecation_warnings(
+            config, DEPRECATED_ALIASES_TO_STANDARD_KEY_MAPPING, "EnterpriseSearchPolicy"
+        )
+        # Resolve any potential aliases (e.g. 'prompt_template' vs 'prompt')
+        config = cls.resolve_config_aliases(config)
+
+        # Validate that the required keys are present
+        validate_required_keys(config, REQUIRED_KEYS)
+        # Validate that the forbidden keys are not present
+        validate_forbidden_keys(config, FORBIDDEN_KEYS)
+
+        this = EnterpriseSearchPolicyConfig(
+            llm_config=llm_config,
+            embeddings_config=embeddings_config,
+            vector_store_config=vector_store_config,
+            prompt_template=config.get(PROMPT_TEMPLATE_CONFIG_KEY),
+            use_generative_llm=config.get(USE_LLM_PROPERTY, DEFAULT_USE_LLM_PROPERTY),
+            enable_citation=config.get(
+                CITATION_ENABLED_PROPERTY, DEFAULT_CITATION_ENABLED_PROPERTY
+            ),
+            check_relevancy=config.get(
+                CHECK_RELEVANCY_PROPERTY, DEFAULT_CHECK_RELEVANCY_PROPERTY
+            ),
+            max_history=config.get(POLICY_MAX_HISTORY),
+            max_messages_in_query=config.get(
+                MAX_MESSAGES_IN_QUERY_KEY, DEFAULT_MAX_MESSAGES_IN_QUERY
+            ),
+            trace_prompt_tokens=config.get(
+                TRACE_TOKENS_PROPERTY, DEFAULT_TRACE_PROMPT_TOKEN_PROPERTY
+            ),
+        )
+        return this
+
+    def to_dict(self) -> dict:
+        """Converts the config instance into a dictionary."""
+        return asdict(self)
+
+    @staticmethod
+    def resolve_config_aliases(config: Dict[str, Any]) -> Dict[str, Any]:
+        return resolve_aliases(config, DEPRECATED_ALIASES_TO_STANDARD_KEY_MAPPING)

rasa/core/policies/enterprise_search_prompt_with_relevancy_check_and_citation_template.jinja2

@@ -0,0 +1,64 @@
+Based on the provided documents and the recent conversation context, answer the following question.
+Before responding, ensure the answer is directly supported by the documents or context.
+Do not make assumptions or infer beyond the given information.
+Only answer if you are more than 80% confident that the response is fully supported.
+If the answer cannot be determined, respond with: [NO_RAG_ANSWER]
+
+### Relevant Documents
+Use the following documents to answer the question:
+{% for doc in docs %}
+{{ loop.cycle("*")}}. {{ doc.metadata }}
+{{ doc.text }}
+{% endfor %}
+
+{% if citation_enabled %}
+### Citing Sources
+Find the sources from the documents that are most relevant to answering the question.
+The sources must be extracted from the given document metadata source property and not from the conversation context.
+If there are no relevant sources, write "No relevant sources" instead.
+
+For each source you cite, follow a 1-based numbering system for citations.
+Start with [1] for the first source you refer to, regardless of its index in the provided list of documents.
+If you cite another source, use the next number in sequence, [2], and so on.
+Ensure each source is only assigned one number, even if referenced multiple times.
+If you refer back to a previously cited source, use its originally assigned number.
+
+For example, if you first cite the third source in the list, refer to it as [1].
+If you then cite the first source in the list, refer to it as [2].
+If you mention the third source again, still refer to it as [1].
+
+Don't say "According to Source [1]" when answering. Instead, make references to sources relevant to each section of the answer solely by adding the bracketed number at the end of the relevant sentence.
+#### Formatting
+First print the answer with in-text citations which follow a numbered order starting with index 1, then add the sources section.
+The format of your overall answer must look like what's shown between the <example></example> tags.
+Make sure to follow the formatting exactly and remove any line breaks or whitespaces between the answer and the Sources section.
+<example>
+You can use flows to model business logic in Rasa assistants. [1] You can use the Enterprise Search Policy to search vector stores for relevant knowledge base documents. [2]
+Sources:
+[1] https://rasa.com/docs/rasa-pro/concepts/flows
+[2] https://rasa.com/docs/rasa-pro/concepts/policies/enterprise-search-policy
+</example>
+{% endif %}
+
+{% if slots|length > 0 %}
+### Slots or Variables
+Here are the variables of the currently active conversation which may be used to answer the question:
+{% for slot in slots -%}
+- name: {{ slot.name }}, value: {{ slot.value }}, type: {{ slot.type }}
+{% endfor %}
+{% endif %}
+### Current Conversation
+Transcript of the current conversation, use it to determine the context of the question:
+{{ current_conversation }}
+
+
+## Answering the Question
+Based on the above sections, please formulate an answer to the question or request in the user's last message.
+It is important that you ensure the answer is grounded in the provided documents and conversation context.
+Avoid speculating or making assumptions beyond the given information and keep your answers short, 2 to 3 sentences at most.
+
+{% if citation_enabled %}
+If you are unable to find an answer in the given relevant documents, do not cite sources from elsewhere in the conversation context.
+{% endif %}
+
+Your answer:

rasa/core/policies/flow_policy.py

@@ -150,12 +150,12 @@ class FlowPolicy(Policy):
         except FlowCircuitBreakerTrippedException as e:
             structlogger.error(
                 "flow.circuit_breaker",
-                dialogue_stack=e.dialogue_stack,
                 number_of_steps_taken=e.number_of_steps_taken,
                 event_info=(
                     "The flow circuit breaker tripped. "
                     "There appears to be an infinite loop in the flows."
                 ),
+                error=str(e),
             )
             # end the current flow and start the internal error flow
             updated_stack = tracker.stack

rasa/core/policies/flows/flow_executor.py

@@ -9,6 +9,7 @@ from structlog.contextvars import (
     bound_contextvars,
 )
 
+from rasa.core.available_endpoints import AvailableEndpoints
 from rasa.core.constants import ACTIVE_FLOW_METADATA_KEY, STEP_ID_METADATA_KEY
 from rasa.core.policies.flows.flow_exceptions import (
     FlowCircuitBreakerTrippedException,
@@ -24,6 +25,7 @@ from rasa.core.policies.flows.flow_step_result import (
 from rasa.dialogue_understanding.commands import CancelFlowCommand
 from rasa.dialogue_understanding.patterns.cancel import CancelPatternFlowStackFrame
 from rasa.dialogue_understanding.patterns.collect_information import (
+    FLOW_PATTERN_COLLECT_INFORMATION,
     CollectInformationPatternFlowStackFrame,
 )
 from rasa.dialogue_understanding.patterns.completed import (
@@ -54,6 +56,7 @@ from rasa.dialogue_understanding.stack.utils import (
 from rasa.shared.constants import RASA_PATTERN_HUMAN_HANDOFF
 from rasa.shared.core.constants import (
     ACTION_LISTEN_NAME,
+    SILENCE_TIMEOUT_SLOT,
 )
 from rasa.shared.core.events import (
     Event,
@@ -123,7 +126,6 @@ def is_condition_satisfied(
         structlogger.error(
             "flow.predicate.error",
             predicate=predicate,
-            document=document,
             error=str(e),
         )
         return False
@@ -177,7 +179,7 @@ def select_next_step_id(
             "flow.link.failed_to_select_branch",
             current=current,
             links=next_step.links,
-            tracker=tracker,
+            sender_id=tracker.sender_id,
         )
         return None
 
@@ -191,7 +193,7 @@ def select_next_step_id(
         structlogger.error(
             "flow.step.failed_to_select_next_step",
             step=current,
-            tracker=tracker,
+            sender_id=tracker.sender_id,
         )
         return None
 
@@ -226,19 +228,6 @@ def events_from_set_slots_step(step: SetSlotsFlowStep) -> List[Event]:
     return [SlotSet(slot["key"], slot["value"]) for slot in step.slots]
 
 
-def events_for_collect_step_execution(
-    step: CollectInformationFlowStep, tracker: DialogueStateTracker
-) -> List[Event]:
-    """Create the events needed to prepare for the execution of a collect step."""
-    # reset the slots that always need to be explicitly collected
-    slot = tracker.slots.get(step.collect, None)
-
-    if slot and step.ask_before_filling:
-        return [SlotSet(step.collect, None)]
-    else:
-        return []
-
-
 def trigger_pattern_continue_interrupted(
     current_frame: DialogueStackFrame,
     stack: DialogueStack,
@@ -600,6 +589,12 @@ def run_step(
         # the START_STEP meta step
         initial_events.append(FlowStarted(flow.id, metadata=stack.current_context()))
 
+    # FLow does not start with collect step or we are not in collect information pattern
+    if _first_step_is_not_collect(
+        step, previous_step_id
+    ) and not _in_collect_information_pattern(flow):
+        _append_global_silence_timeout_event(initial_events, tracker)
+
     if isinstance(step, CollectInformationFlowStep):
         return _run_collect_information_step(
             available_actions,
@@ -629,12 +624,32 @@ def run_step(
         return ContinueFlowWithNextStep(events=initial_events)
 
     elif isinstance(step, EndFlowStep):
+        # If pattern collect information flow is ending,
+        # we need to reset the silence timeout slot to its global value.
+        if flow.id == FLOW_PATTERN_COLLECT_INFORMATION:
+            _append_global_silence_timeout_event(initial_events, tracker)
+
         return _run_end_step(flow, flows, initial_events, stack, tracker)
 
     else:
         raise FlowException(f"Unknown flow step type {type(step)}")
 
 
+def _first_step_is_not_collect(
+    step: FlowStep,
+    previous_step_id: str,
+) -> bool:
+    """Check if the first step is not a collect information step."""
+    return (previous_step_id == START_STEP) and not isinstance(
+        step, CollectInformationFlowStep
+    )
+
+
+def _in_collect_information_pattern(flow: Flow) -> bool:
+    """Check if the current flow is a collect information pattern."""
+    return flow.id == FLOW_PATTERN_COLLECT_INFORMATION
+
+
 def _run_end_step(
     flow: Flow,
     flows: FlowsList,
@@ -745,5 +760,69 @@ def _run_collect_information_step(
         step.collect, stack, step.rejections, step.utter, step.collect_action
     )
 
-    events: List[Event] = events_for_collect_step_execution(step, tracker)
+    events: List[Event] = _events_for_collect_step_execution(step, tracker)
     return ContinueFlowWithNextStep(events=initial_events + events)
+
+
+def _events_for_collect_step_execution(
+    step: CollectInformationFlowStep, tracker: DialogueStateTracker
+) -> List[Event]:
+    """Create the events needed to prepare for the execution of a collect step."""
+    # reset the slots that always need to be explicitly collected
+
+    events = _silence_timeout_events_for_collect_step(step, tracker)
+
+    slot = tracker.slots.get(step.collect, None)
+    if slot and step.ask_before_filling:
+        events.append(SlotSet(step.collect, None))
+
+    return events
+
+
+def _silence_timeout_events_for_collect_step(
+    step: CollectInformationFlowStep, tracker: DialogueStateTracker
+) -> List[Event]:
+    events: List[Event] = []
+
+    silence_timeout = (
+        AvailableEndpoints.get_instance().interaction_handling.global_silence_timeout
+    )
+
+    if step.silence_timeout:
+        structlogger.debug(
+            "flow.step.run.adjusting_silence_timeout",
+            duration=step.silence_timeout,
+            collect=step.collect,
+        )
+
+        silence_timeout = step.silence_timeout
+    else:
+        structlogger.debug(
+            "flow.step.run.reset_silence_timeout_to_global",
+            duration=silence_timeout,
+            collect=step.collect,
+        )
+
+    current_silence_timeout = tracker.get_slot(SILENCE_TIMEOUT_SLOT)
+
+    if current_silence_timeout != silence_timeout:
+        events.append(SlotSet(SILENCE_TIMEOUT_SLOT, silence_timeout))
+
+    return events
+
+
+def _append_global_silence_timeout_event(
+    events: List[Event], tracker: DialogueStateTracker
+) -> None:
+    current_silence_timeout = tracker.get_slot(SILENCE_TIMEOUT_SLOT)
+    global_silence_timeout = (
+        AvailableEndpoints.get_instance().interaction_handling.global_silence_timeout
+    )
+
+    if current_silence_timeout != global_silence_timeout:
+        events.append(
+            SlotSet(
+                SILENCE_TIMEOUT_SLOT,
+                AvailableEndpoints.get_instance().interaction_handling.global_silence_timeout,
+            )
+        )