rasa-pro 3.13.1a18__py3-none-any.whl → 3.13.1a20__py3-none-any.whl

rasa/builder/shared/tracker_context.py

@@ -0,0 +1,212 @@
+from typing import Any, Dict, List, Optional
+
+from pydantic import BaseModel, Field
+
+from rasa.builder.copilot.constants import ROLE_ASSISTANT, ROLE_USER
+from rasa.shared.core.constants import DEFAULT_SLOT_NAMES
+from rasa.shared.core.events import (
+    ActionExecuted,
+    BotUttered,
+    FlowCompleted,
+    FlowStarted,
+    SlotSet,
+    UserUttered,
+)
+from rasa.shared.core.trackers import DialogueStateTracker
+
+
+class AssistantMessage(BaseModel):
+    text: str
+
+
+class UserMessage(BaseModel):
+    text: str
+    predicted_commands: List[str] = Field(default_factory=list)
+
+
+class TrackerEvent(BaseModel):
+    event: str
+    data: Dict[str, Any] = Field(default_factory=dict)
+
+
+class AssistantConversationTurn(BaseModel):
+    user_message: Optional[UserMessage] = None
+    assistant_messages: List[AssistantMessage] = Field(default_factory=list)
+    context_events: List[TrackerEvent] = Field(default_factory=list)
+
+
+class CurrentState(BaseModel):
+    latest_message: Optional[str] = None
+    active_flow: Optional[str] = None
+    flow_stack: Optional[List[Dict[str, Any]]] = None
+    slots: Optional[Dict[str, Any]] = None
+    latest_action: Optional[str] = None
+    followup_action: Optional[str] = None
+
+
+class TrackerContext(BaseModel):
+    conversation_turns: List[AssistantConversationTurn]
+    current_state: CurrentState
+
+    def to_openai_format(self) -> List[Dict[str, Any]]:
+        """Convert the TrackerContext to a format suitable for OpenAI.
+
+        Returns:
+            A list of user and assistant messages in the format suitable for OpenAI.
+        """
+        messages: List[Dict[str, Any]] = []
+        for turn in self.conversation_turns:
+            if turn.user_message:
+                messages.append({"role": ROLE_USER, "content": turn.user_message.text})
+            for message in turn.assistant_messages:
+                messages.append({"role": ROLE_ASSISTANT, "content": message.text})
+        return messages
+
+    @classmethod
+    def from_tracker(
+        cls, tracker: Optional[DialogueStateTracker], max_turns: int = 10
+    ) -> Optional["TrackerContext"]:
+        """Convert a tracker to a TrackerContext."""
+        if not tracker or not tracker.events:
+            return None
+
+        conversation_turns = cls._build_conversation_turns(tracker)
+        conversation_turns = conversation_turns[-max_turns:]
+        current_state = cls._build_current_state(tracker)
+
+        return cls(
+            conversation_turns=conversation_turns,
+            current_state=current_state,
+        )
+
+    @classmethod
+    def _build_conversation_turns(
+        cls, tracker: DialogueStateTracker
+    ) -> List[AssistantConversationTurn]:
+        """Build conversation turns from tracker events."""
+        conversation_turns: List[AssistantConversationTurn] = []
+        current_user_message: Optional[UserMessage] = None
+        current_assistant_messages: List[AssistantMessage] = []
+        current_context_events: List[TrackerEvent] = []
+
+        for event in tracker.applied_events():
+            if isinstance(event, UserUttered):
+                # Save previous turn if exists and has content. A new turn starts with a
+                # user message. However, since it's possible that "turn" started with an
+                # assistant message, we save that turn without the user message.
+                if (
+                    current_user_message
+                    or current_assistant_messages
+                    or current_context_events
+                ):
+                    conversation_turns.append(
+                        AssistantConversationTurn(
+                            user_message=current_user_message,
+                            assistant_messages=current_assistant_messages,
+                            context_events=current_context_events,
+                        )
+                    )
+                current_assistant_messages = []
+                current_context_events = []
+
+                # Start new turn
+
+                # Fetch the predicted commands for the user message
+                predicted_commands = (
+                    [command.get("command") for command in event.commands]
+                    if event.commands
+                    else []
+                )
+
+                current_user_message = UserMessage(
+                    text=event.text or "",
+                    predicted_commands=predicted_commands,
+                )
+
+            # Assistant conversation turn can have multiple messages from the assistant
+            elif isinstance(event, BotUttered):
+                current_assistant_messages.append(
+                    AssistantMessage(text=event.text or "")
+                )
+
+            # Handle non-user and non-assistant events. These are useful for more
+            # adding context to the conversation turn.
+            else:
+                context_event = cls._process_tracker_event(event)
+                if context_event:
+                    current_context_events.append(context_event)
+
+        # Add the final turn if there is one
+        if current_user_message or current_assistant_messages:
+            conversation_turns.append(
+                AssistantConversationTurn(
+                    user_message=current_user_message,
+                    assistant_messages=current_assistant_messages,
+                    context_events=current_context_events,
+                )
+            )
+
+        return conversation_turns
+
+    @staticmethod
+    def _process_tracker_event(event: Any) -> Optional[TrackerEvent]:
+        if isinstance(event, ActionExecuted):
+            return TrackerEvent(
+                event=ActionExecuted.type_name,
+                data={"action_name": event.action_name, "confidence": event.confidence},
+            )
+
+        elif isinstance(event, SlotSet) and event.key not in DEFAULT_SLOT_NAMES:
+            return TrackerEvent(
+                event=SlotSet.type_name,
+                data={"slot_name": event.key, "slot_value": event.value},
+            )
+
+        elif isinstance(event, FlowStarted):
+            return TrackerEvent(
+                event=FlowStarted.type_name,
+                data={"flow_id": event.flow_id},
+            )
+
+        elif isinstance(event, FlowCompleted):
+            return TrackerEvent(
+                event=FlowCompleted.type_name,
+                data={"flow_id": event.flow_id},
+            )
+        else:
+            return None
+
+    @classmethod
+    def _build_current_state(cls, tracker: DialogueStateTracker) -> CurrentState:
+        """Build the current state from the tracker."""
+        latest_message = tracker.latest_message.text if tracker.latest_message else None
+        latest_action = (
+            tracker.latest_action.get("action_name") if tracker.latest_action else None
+        )
+        followup_action = tracker.followup_action
+        flow_stack = tracker.stack.as_dict() if tracker.stack else None
+        slots = cls._extract_non_default_slots(tracker)
+        active_flow = tracker.active_flow
+
+        return CurrentState(
+            latest_message=latest_message,
+            active_flow=active_flow,
+            flow_stack=flow_stack,
+            latest_action=latest_action,
+            followup_action=followup_action,
+            slots=slots,
+        )
+
+    @classmethod
+    def _extract_non_default_slots(
+        cls, tracker: DialogueStateTracker
+    ) -> Optional[Dict[str, Any]]:
+        """Extract non-default slot values from the tracker."""
+        if not tracker.slots:
+            return None
+
+        return {
+            k: str(v.value)
+            for k, v in tracker.slots.items()
+            if v is not None and k not in DEFAULT_SLOT_NAMES
+        }

rasa/builder/validation_service.py

@@ -2,7 +2,7 @@
 
 import sys
 from contextlib import contextmanager
-from typing import Optional
+from typing import Any, Dict, Generator, Optional
 
 import structlog
 from structlog.testing import capture_logs
@@ -16,15 +16,15 @@ structlogger = structlog.get_logger()
 
 
 @contextmanager
-def _mock_sys_exit():
+def _mock_sys_exit() -> Generator[Dict[str, bool], Any, None]:
     """Context manager to prevent sys.exit from being called during validation."""
     was_sys_exit_called = {"value": False}
 
-    def sys_exit_mock(code: int = 0):
+    def sys_exit_mock(code: int = 0) -> None:
         was_sys_exit_called["value"] = True
 
     original_exit = sys.exit
-    sys.exit = sys_exit_mock
+    sys.exit = sys_exit_mock  # type: ignore[assignment]
 
     try:
         yield was_sys_exit_called

rasa/cli/data.py

@@ -205,9 +205,14 @@ def _build_training_data_importer(args: argparse.Namespace) -> "TrainingDataImpo
         args.domain, "domain", DEFAULT_DOMAIN_PATHS, none_is_valid=False
     )
 
-    return TrainingDataImporter.load_from_config(
-        domain_path=domain, training_data_paths=args.data, config_path=config
-    )
+    if config:
+        return TrainingDataImporter.load_from_config(
+            domain_path=domain, training_data_paths=args.data, config_path=config
+        )
+    else:
+        return TrainingDataImporter.load_from_dict(
+            domain_path=domain, training_data_paths=args.data, config_path=config
+        )
 
 
 def _append_story_structure_arguments(parser: argparse.ArgumentParser) -> None:

rasa/cli/project_templates/basic/actions/action_api.py

@@ -0,0 +1,15 @@
+from typing import Any, Dict, List, Text
+
+from rasa_sdk import Action, Tracker
+from rasa_sdk.executor import CollectingDispatcher
+from rasa_sdk.types import DomainDict
+
+
+class ActionAPI(Action):
+    def name(self) -> Text:
+        return "action_api"
+
+    async def run(
+        self, dispatcher: CollectingDispatcher, tracker: Tracker, domain: DomainDict
+    ) -> List[Dict[Text, Any]]:
+        return []

rasa/cli/project_templates/basic/actions/action_human_handoff.py

@@ -0,0 +1,44 @@
+from typing import Any, Dict, List, Text
+
+import openai
+from rasa_sdk import Action, Tracker
+from rasa_sdk.events import BotUttered
+from rasa_sdk.executor import CollectingDispatcher
+from rasa_sdk.types import DomainDict
+
+
+class ActionHumanHandoff(Action):
+    def name(self) -> Text:
+        return "action_human_handoff"
+
+    async def run(
+        self, dispatcher: CollectingDispatcher, tracker: Tracker, domain: DomainDict
+    ) -> List[Dict[Text, Any]]:
+        # Collect conversation
+        convo = []
+        for event in tracker.events:
+            if event.get("event") == "user":
+                user_text = f"user - {event.get('text')}"
+                convo.append(user_text)
+            if event.get("event") == "bot":
+                bot_text = f"bot - {event.get('text')}"
+                convo.append(bot_text)
+        prompt = (
+            f"The following is a conversation between a bot and a human user, "
+            f"please summarise so that a human agent can easily understand "
+            f"the important context. Conversation: {convo}"
+        )
+        response = openai.chat.completions.create(
+            model="gpt-4",  # or "gpt-3.5-turbo"
+            messages=[{"role": "user", "content": prompt}],
+        )
+        summarised_conversation = (
+            response.choices[0].message.content or "No summary available"
+        )
+        return [
+            BotUttered(
+                f"I will transfer the following summary of our conversation "
+                f"to the Callback Manager:\n"
+                f"{summarised_conversation}"
+            )
+        ]

rasa/cli/project_templates/basic/config.yml

@@ -0,0 +1,23 @@
+# This file contains the configuration for the bot.
+# https://rasa.com/docs/reference/config/overview
+
+recipe: default.v1
+language: en
+assistant_id: placeholder_default
+
+pipeline:
+- name: SearchReadyLLMCommandGenerator
+  llm:
+    model_group: openai-gpt-4o
+  flow_retrieval:
+    active: false
+
+policies:
+- name: FlowPolicy
+- name: EnterpriseSearchPolicy
+  vector_store:
+    type: "faiss"
+    source: "./docs"
+  llm:
+    model_group: openai-gpt-4o
+  check_relevancy: true

rasa/cli/project_templates/{plain → basic}/credentials.yml

@@ -1,11 +1,15 @@
+
 # This file contains the credentials for the voice & chat platforms
 # which your bot is using.
 # https://rasa.com/docs/rasa-pro/connectors/messaging-and-voice-channels/
-
 rest:
-#  # you don't need to provide anything here - this channel doesn't
-#  # require any credentials
+socketio:
+  bot_message_evt: bot_uttered
+  session_persistence: true
+  user_message_evt: user_uttered
 
+rasa:
+  url: "http://localhost:5002/api"
 
 #facebook:
 #  verify: "<verify>"
@@ -27,7 +31,4 @@ rest:
 #  token: "<bot token>"
 #  webhook_url: "<callback URL>"
 
-# This entry is needed if you are using Rasa Enterprise. The entry represents credentials
-# for the Rasa Enterprise "channel", i.e. Talk to your bot and Share with guest testers.
-rasa:
-  url: "http://localhost:5002/api"
+

rasa/cli/project_templates/basic/data/general/feedback.yml

@@ -0,0 +1,20 @@
+# Simple thumbs up/down feedback flow
+flows:
+  leave_feedback:
+    description: This flow collects simple thumbs up or thumbs down feedback
+    if: False # Flow guard to prevent direct triggering
+    steps:
+      - collect: feedback_rating
+        description: Ask user for thumbs up or thumbs down feedback
+      - id: feedback_response
+        noop: true
+        next:
+          - if: slots.feedback_rating == "thumbs_up"
+            then: positive_response
+          - else: negative_response
+      - id: positive_response
+        action: utter_thankyou_positive
+        next: END
+      - id: negative_response
+        action: utter_thankyou_negative
+        next: END

rasa/cli/project_templates/basic/data/general/goodbye.yml

@@ -0,0 +1,6 @@
+flows: 
+  goodbye_flow:
+    description: Handle user goodbye messages, say farewell, and collect feedback
+    steps:
+      - action: utter_goodbye
+      - link: leave_feedback

rasa/cli/project_templates/basic/data/general/hello.yml

@@ -0,0 +1,7 @@
+flows:
+  hello:
+    description: Flow for greeting the user hello
+    name: hello
+    steps:
+      - action: utter_greeting
+

rasa/cli/project_templates/basic/data/general/help.yml

@@ -0,0 +1,6 @@
+flows:
+  help:
+    description: Answer the users question on what the assistant can do to help them
+    name: help
+    steps:
+      - action: utter_help

rasa/cli/project_templates/basic/data/general/human_handoff.yml

@@ -0,0 +1,16 @@
+version: "3.1"
+flows:
+  human_handoff:
+    description: Handles escalation to a live human agent.
+    steps:
+      - collect: confirm_human_handoff
+        ask_before_filling: True
+        next:
+          - if: slots.confirm_human_handoff is "Yes"
+            then:
+              - action: utter_transferring_to_human
+              - action: action_human_handoff
+                next: END
+          - else:
+              - action: utter_human_handoff_cancelled
+                next: END

rasa/cli/project_templates/basic/data/general/welcome.yml

@@ -0,0 +1,9 @@
+flows:
+  welcome:
+    if: False
+    description: |
+      This flow is designed to greet and onboard new users who initiate a welcome intent.
+      It begins with an initial greeting message to establish a friendly interaction.
+    name: say hello
+    steps:
+      - action: utter_greeting

rasa/cli/project_templates/{finance/data/patterns → basic/data/system}/pattern_completed.yml

@@ -1,6 +1,7 @@
-flows:
+flows: 
   pattern_completed:
     description: A flow has been completed and there is nothing else to be done
+    if: False
     steps:
       - noop: true
         next: END

rasa/cli/project_templates/basic/data/system/pattern_correction.yml

@@ -0,0 +1,7 @@
+flows:
+  pattern_correction:
+    description: Handle a correction of a slot value.
+    name: pattern correction
+    steps:
+      - action: action_correct_flow_slot
+        next: "END"

rasa/cli/project_templates/basic/data/system/pattern_search.yml

@@ -0,0 +1,8 @@
+flows:
+  pattern_search:
+    name: pattern_search
+    description: Flow for handling knowledge-based questions
+    steps:
+    - id: 0_action_trigger_search
+      next: END
+      action: action_trigger_search

rasa/cli/project_templates/basic/data/system/pattern_session_start.yml

@@ -0,0 +1,8 @@
+flows:
+  pattern_session_start:
+    description: Flow for starting the conversation
+    name: pattern session start
+    nlu_trigger:
+        - intent: session_start
+    steps:
+      - link: hello

rasa/cli/project_templates/basic/docs/rasa_assistant_qa.txt

@@ -0,0 +1,65 @@
+1. Rasa Assistant Capabilities
+
+Q: What is a Rasa assistant?
+A: A Rasa assistant is an AI-powered conversational bot built using the Rasa framework. It can understand natural language, manage complex conversations, execute actions, and integrate with external systems to help users accomplish tasks through text or voice interactions.
+
+Q: What types of tasks can Rasa assistants handle?
+A: Rasa assistants can handle a wide variety of tasks including customer support, booking appointments, processing transactions, answering FAQs, collecting information through forms, routing calls to human agents, providing personalized recommendations, and integrating with databases and APIs.
+
+Q: How does a Rasa assistant understand what users say?
+A: Rasa assistants use Natural Language Understanding (NLU) to interpret user messages. They can extract intents (what the user wants to do) and entities (important information like names, dates, amounts) from text. Rasa Pro also supports LLM-based understanding for more flexible conversation handling.
+
+2. Conversation Management
+
+Q: Can Rasa assistants handle complex conversations?
+A: Yes, Rasa assistants excel at managing complex, multi-turn conversations. They use dialogue management to track conversation context, remember previous interactions, and guide users through multi-step processes like filling out forms or completing transactions.
+
+Q: What are Rasa flows?
+A: Rasa flows are a powerful feature that allows you to define conversational workflows with branching logic, conditional steps, and data collection. They make it easy to create structured conversations for tasks like onboarding, troubleshooting, or gathering customer information.
+
+Q: Can the assistant handle interruptions and context switching?
+A: Absolutely! Rasa assistants can handle conversation repairs, interruptions, clarifications, and context switching. Users can change topics mid-conversation or ask for help, and the assistant will respond appropriately while maintaining conversation state.
+
+3. Integration and Actions
+
+Q: Can Rasa assistants connect to external systems?
+A: Yes, Rasa assistants can integrate with virtually any external system through custom actions. They can connect to databases, APIs, CRM systems, payment processors, booking systems, and more to perform real-world tasks on behalf of users.
+
+Q: What are custom actions in Rasa?
+A: Custom actions are Python functions that allow your assistant to perform specific tasks like querying databases, calling APIs, processing payments, sending emails, or any other business logic. They bridge the gap between conversation and real-world actions.
+
+Q: Can Rasa assistants work with existing business systems?
+A: Yes, Rasa assistants are designed to integrate seamlessly with existing business infrastructure. They can connect to your CRM, ERP, databases, microservices, and other enterprise systems through APIs and custom integrations.
+
+4. Advanced Features
+
+Q: Does Rasa support voice interactions?
+A: Yes, Rasa assistants can handle voice interactions through integration with speech-to-text and text-to-speech services. They can be deployed as voice bots for phone systems or voice-enabled applications.
+
+Q: Can Rasa assistants learn and improve over time?
+A: Rasa assistants can be continuously improved through conversation analytics, user feedback, and retraining with new data. Rasa X (now part of Rasa Pro) provides tools for reviewing conversations and improving assistant performance.
+
+Q: What is CALM in Rasa?
+A: CALM (Conversational AI with Language Models) is Rasa's architecture that combines traditional rule-based dialogue management with large language models. This provides both reliability and flexibility, allowing for structured workflows while handling unexpected user inputs gracefully.
+
+5. Deployment and Scaling
+
+Q: Where can Rasa assistants be deployed?
+A: Rasa assistants can be deployed anywhere - on websites as chatbots, in mobile apps, on messaging platforms (WhatsApp, Slack, Facebook Messenger), as voice bots, in call centers, or as standalone applications. They're platform-agnostic and highly flexible.
+
+Q: Can Rasa assistants handle multiple languages?
+A: Yes, Rasa supports multilingual assistants. You can train models in different languages and create assistants that can communicate with users in their preferred language.
+
+Q: How do Rasa assistants scale for enterprise use?
+A: Rasa assistants are built for enterprise scale with features like clustering, load balancing, conversation analytics, version control for models, A/B testing capabilities, and enterprise-grade security and compliance features.
+
+6. Use Cases and Industries
+
+Q: What industries use Rasa assistants?
+A: Rasa assistants are used across many industries including banking and finance, healthcare, e-commerce, telecommunications, insurance, travel and hospitality, education, and government services. Any industry that needs to automate customer interactions can benefit.
+
+Q: Can Rasa assistants replace human agents?
+A: Rasa assistants are designed to augment human agents, not replace them. They can handle routine inquiries and tasks, freeing up human agents for complex issues that require empathy, creativity, or specialized knowledge. They can also seamlessly hand off conversations to humans when needed.
+
+Q: What's the difference between Rasa and simple chatbots?
+A: Unlike simple rule-based chatbots, Rasa assistants can understand context, handle complex multi-turn conversations, learn from interactions, integrate with business systems, and manage sophisticated workflows. They're true conversational AI rather than basic question-answering systems. 

rasa/cli/project_templates/basic/docs/template.txt

@@ -0,0 +1,7 @@
+1. General Questions
+
+Q: What else can you do?
+A: I can answer questions from docs. Add more txt files to /docs to get started. 
+
+Q: Can you do RAG?
+A: Yes, you can use Retrieval-Augmented Generation (RAG) with Rasa. Rasa's CALM architecture supports RAG through its Enterprise Search Policy. Right now, I'm just retrieving messages from the /docs folder for demo purposes. Add more txt files to /docs to test it out.

rasa/cli/project_templates/basic/domain/general/assistant_details.yml

@@ -0,0 +1,12 @@
+slots:
+  skills_summary:
+    type: text
+    initial_value: "general questions or direct you to an available agent"
+    mappings:
+      - type: controlled
+  assistant_name:
+    type: text
+    initial_value: "Vanessa"
+    mappings:
+      - type: controlled
+

rasa/cli/project_templates/basic/domain/general/bot_identity.yml

@@ -0,0 +1,5 @@
+responses:
+  utter_bot_identity:
+    - text: "Yes, I'm an AI assistant designed to help you with your questions. I'm here to provide helpful information and support. How can I assist you today?"
+    - text: "I am indeed an AI assistant! I'm programmed to be helpful, accurate, and friendly. What can I help you with?"
+    - text: "That's right, I'm an AI bot created to assist you. I aim to provide useful responses and help solve your questions. Is there something specific I can help you with?"

rasa/cli/project_templates/basic/domain/general/cannot_handle.yml

@@ -0,0 +1,5 @@
+responses:
+  utter_no_relevant_answer_found:
+    - text: I’m sorry, I can’t help with that.
+      metadata:
+        rephrase: False

rasa/cli/project_templates/basic/domain/general/feedback.yml

@@ -0,0 +1,28 @@
+slots:
+  feedback_rating:
+    type: categorical
+    values: [thumbs_up, thumbs_down]
+    mappings:
+      - type: from_llm
+
+responses:
+  utter_ask_feedback_rating:
+    - text: "Before you go, how was your experience?"
+      buttons:
+        - title: "👍 Great"
+          payload: "/SetSlots(feedback_rating=thumbs_up)"
+        - title: "👎 Could be better"
+          payload: "/SetSlots(feedback_rating=thumbs_down)"
+
+  utter_thankyou_positive:
+    - text: "That's wonderful to hear! Thank you for your feedback! Have a fantastic day! 🌟"
+    - text: "So glad we could help! Thanks for the positive feedback! Take care! 😊"
+    - text: "Amazing! We're thrilled you had a great experience. Have a wonderful day! 🎉"
+
+  utter_thankyou_negative:
+    - text: "Thank you for your honest feedback. We're always working to improve our service. Have a good day."
+    - text: "We appreciate your feedback and will use it to make our service better. Thank you for your time."
+    - text: "Thanks for letting us know. Your feedback helps us improve. Take care!"
+
+actions:
+  - action_default_fallback

rasa/cli/project_templates/basic/domain/general/goodbye.yml

@@ -0,0 +1,7 @@
+responses: 
+  utter_goodbye:
+    - text: "Thanks for stopping by — take care!"
+    - text: "Thanks for the chat. Have a great day!"
+    - text: "Catch you later! Feel free to reach out anytime."
+    - text: "Goodbye for now — we’re here if you need anything."
+    - text: "Take care! Let us know if you have any other questions."

rasa/cli/project_templates/basic/domain/general/help.yml

@@ -0,0 +1,5 @@
+version: "3.1"
+
+responses:
+  utter_help:
+    - text: "I can help you with {skills_summary}."