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

rasa/cli/project_templates/basic/tests/e2e_test_cases/without_stub/general/human_handoff.yml

@@ -0,0 +1,41 @@
+test_cases:
+  - test_case: human handoff happy path
+    steps:
+    - user: "I would like to speak with a human"
+      assertions:
+        - flow_started: "human_handoff"
+        - bot_uttered:
+            utter_name: "utter_ask_confirm_human_handoff"
+            buttons:
+              - payload: "/SetSlots(confirm_human_handoff=Yes)"
+                title: "Yes"
+              - payload: "/SetSlots(confirm_human_handoff=No)"
+                title: "No"
+    - user: "/SetSlots(confirm_human_handoff=Yes)"
+      assertions:
+        - slot_was_set:
+            - name: "confirm_human_handoff"
+              value: "Yes"
+        - bot_uttered:
+            utter_name: "utter_transferring_to_human"
+        - action_executed: action_human_handoff
+# ====================================================>
+  - test_case: human handoff unhappy path
+    steps:
+    - user: "I would like to speak with a human"
+      assertions:
+        - flow_started: "human_handoff"
+        - bot_uttered:
+            utter_name: "utter_ask_confirm_human_handoff"
+            buttons:
+              - payload: "/SetSlots(confirm_human_handoff=Yes)"
+                title: "Yes"
+              - payload: "/SetSlots(confirm_human_handoff=No)"
+                title: "No"
+    - user: "/SetSlots(confirm_human_handoff=No)"
+      assertions:
+        - slot_was_set:
+            - name: "confirm_human_handoff"
+              value: "No"
+        - bot_uttered:
+            utter_name: "utter_human_handoff_cancelled"

rasa/cli/project_templates/basic/tests/e2e_test_cases/without_stub/general/patterns.yml

@@ -0,0 +1,32 @@
+test_cases:
+- test_case: test pattern session start
+  steps:
+    - user: "/session_start"
+      assertions:
+        - flow_started: "pattern_session_start"
+        - bot_uttered:
+            utter_name: "utter_welcome"
+#
+- test_case: test basic conversation flow
+  steps:
+    - user: "hello"
+      assertions:
+        - flow_started: "hello"
+        - bot_uttered:
+            utter_name: "utter_hello"
+    - user: "what can you help me with?"
+      assertions:
+        - flow_started: "help"
+        - bot_uttered:
+            utter_name: "utter_what_can_you_do"
+    - user: "show me faqs"
+      assertions:
+        - flow_started: "show_faqs"
+        - bot_uttered:
+            utter_name: "utter_top_faqs"
+    - user: "goodbye"
+      assertions:
+        - flow_started: "goodbye_flow"
+        - bot_uttered:
+            utter_name: "utter_goodbye"
+        - flow_started: "leave_feedback"

rasa/cli/project_templates/basic/tests/e2e_test_cases/without_stub/general/show_faqs.yml

@@ -0,0 +1,8 @@
+test_cases:
+  - test_case: show faqs
+    steps:
+    - user: "show me the faqs"
+      assertions:
+        - flow_started: "show_faqs"
+        - bot_uttered:
+            utter_name: "utter_top_faqs"

rasa/cli/project_templates/default/config.yml

@@ -15,3 +15,7 @@ pipeline:
 policies:
 - name: FlowPolicy
 - name: IntentlessPolicy
+  llm:
+    model_group: openai-gpt-4o
+  embeddings:
+    model_group: openai-embeddings

rasa/cli/project_templates/default/endpoints.yml

@@ -56,3 +56,7 @@ model_groups:
         model: gpt-4o-2024-11-20
         request_timeout: 7
         max_tokens: 256
+  - id: openai-embeddings
+    models:
+      - provider: openai
+        model: text-embedding-3-large

rasa/cli/project_templates/defaults.py

@@ -138,6 +138,7 @@ def get_rasa_defaults(config_yaml: Text, endpoints_yaml: Text) -> RasaDefaults:
         A RasaDefaults object containing the default values for the project.
     """
     config = read_yaml(config_yaml)
+    # Does not read from file, it converts the YAML content to a dictionary.
     endpoints = read_yaml(endpoints_yaml)
 
     prompts = get_system_default_prompts(config, endpoints)

rasa/cli/project_templates/finance/README.md

@@ -0,0 +1,26 @@
+# Finance Banking Agent Template
+
+A lightweight banking conversational agent template for the fictional **Fenlo Bank** that handles account management, card services, and money transfers.
+
+## 🚀 What's Included
+
+This template provides a banking assistant with:
+- **Account Management**: Balance checking and statement downloads
+- **Card Services**: Card activation, blocking, replacement, and listing  
+- **Money Transfers**: Account-to-account transfers and third-party payments
+- **Contact Management**: Add, list, and remove trusted contacts
+- **Bill Management**: Bill payment reminders and scheduling
+- **Banking Knowledge**: FAQ system with Fenlo Bank documentation
+
+## 📁 Directory Structure
+
+```
+├── actions/         # Custom Python logic for banking operations
+├── data/            # Banking conversation flows and training data
+├── domain/          # Banking agent configuration
+├── db/              # Mock JSON database for testing
+├── docs/            # Fenlo Bank knowledge base and FAQ documents
+├── prompts/         # LLM prompts for enhanced banking responses
+└── config.yml       # Training pipeline configuration
+```
+

rasa/cli/project_templates/finance/actions/accounts/check_balance.py

@@ -0,0 +1,18 @@
+from typing import Any, Dict, List
+
+from rasa_sdk import Action, Tracker
+from rasa_sdk.events import SlotSet
+from rasa_sdk.executor import CollectingDispatcher
+
+from actions.db import get_account
+
+
+class CheckBalance(Action):
+    def name(self) -> str:
+        return "check_balance"
+
+    def run(
+        self, dispatcher: CollectingDispatcher, tracker: Tracker, domain: Dict[str, Any]
+    ) -> List[Dict[str, Any]]:
+        account = get_account(tracker.sender_id)
+        return [SlotSet("current_balance", account.funds)]

rasa/cli/project_templates/finance/actions/actions.md

@@ -0,0 +1,15 @@
+## 📂 `actions/` – The Agent's Toolkit
+
+This folder contains Python files that define custom banking actions your agent can perform. Actions handle complex banking operations, database interactions, and business logic validation.
+
+**What you'll find:**
+- **accounts/**: Account-related actions (balance checking, account validation)
+- **cards/**: Card management actions (card existence checks, status updates)
+- **transfers/**: Payment and transfer actions (payee management, fund transfers, scheduling)
+- **contacts/**: Contact and advisor management
+- `database.py`: Core database interactions with banking data
+- `action_session_start.py`: Session initialization for banking context
+
+**Edit Python files in this folder** to add new banking features, modify business rules, or integrate with external banking APIs and systems.
+
+Learn more about custom actions in the [Rasa documentation](https://rasa.com/docs/pro/build/custom-actions).

rasa/cli/project_templates/finance/actions/cards/check_that_card_exists.py

@@ -0,0 +1,21 @@
+from typing import Any, Dict, List, Text
+
+from rasa_sdk import Action, Tracker
+from rasa_sdk.events import SlotSet
+from rasa_sdk.executor import CollectingDispatcher
+
+
+class ActionCheckThatCardExists(Action):
+    def name(self) -> Text:
+        return "check_that_card_exists"
+
+    def run(
+        self,
+        dispatcher: CollectingDispatcher,
+        tracker: Tracker,
+        domain: Dict[Text, Any],
+    ) -> List[Dict[Text, Any]]:
+        # For example purposes, we assume the card exists; in a real situation,
+        # fetch this info from a database or service.
+        # card_number = tracker.get_slot("bank_card_number")
+        return [SlotSet("return_value", True)]

rasa/cli/project_templates/finance/actions/cards/list_cards.py

@@ -0,0 +1,22 @@
+from typing import Any, Dict, List
+
+from rasa_sdk import Action, Tracker
+from rasa_sdk.events import SlotSet
+from rasa_sdk.executor import CollectingDispatcher
+
+from actions.db import get_cards
+
+
+class ListCards(Action):
+    def name(self) -> str:
+        return "list_cards"
+
+    def run(
+        self, dispatcher: CollectingDispatcher, tracker: Tracker, domain: Dict[str, Any]
+    ) -> List[Dict[str, Any]]:
+        cards = get_cards(tracker.sender_id)
+        if len(cards) > 0:
+            cards_list = "".join([f"- {c.name} ({c.handle}) \n" for c in cards])
+            return [SlotSet("cards_list", cards_list)]
+        else:
+            return [SlotSet("cards_list", None)]

rasa/cli/project_templates/finance/actions/contacts/add_contact.py

@@ -0,0 +1,30 @@
+from typing import Any, Dict, List
+
+from rasa_sdk import Action, Tracker
+from rasa_sdk.events import SlotSet
+from rasa_sdk.executor import CollectingDispatcher
+
+from actions.db import Contact, add_contact, get_contacts
+
+
+class AddContact(Action):
+    def name(self) -> str:
+        return "add_contact"
+
+    def run(
+        self, dispatcher: CollectingDispatcher, tracker: Tracker, domain: Dict[str, Any]
+    ) -> List[Dict[str, Any]]:
+        contacts = get_contacts(tracker.sender_id)
+        name = tracker.get_slot("add_contact_name")
+        handle = tracker.get_slot("add_contact_handle")
+
+        if name is None or handle is None:
+            return [SlotSet("return_value", "data_not_present")]
+
+        existing_handles = {c.handle for c in contacts}
+        if handle in existing_handles:
+            return [SlotSet("return_value", "already_exists")]
+
+        new_contact = Contact(name=name, handle=handle)
+        add_contact(tracker.sender_id, new_contact)
+        return [SlotSet("return_value", "success")]

rasa/cli/project_templates/finance/actions/contacts/list_contacts.py

@@ -0,0 +1,22 @@
+from typing import Any, Dict, List
+
+from rasa_sdk import Action, Tracker
+from rasa_sdk.events import SlotSet
+from rasa_sdk.executor import CollectingDispatcher
+
+from actions.db import get_contacts
+
+
+class ListContacts(Action):
+    def name(self) -> str:
+        return "list_contacts"
+
+    def run(
+        self, dispatcher: CollectingDispatcher, tracker: Tracker, domain: Dict[str, Any]
+    ) -> List[Dict[str, Any]]:
+        contacts = get_contacts(tracker.sender_id)
+        if len(contacts) > 0:
+            contacts_list = "".join([f"- {c.name} ({c.handle}) \n" for c in contacts])
+            return [SlotSet("contacts_list", contacts_list)]
+        else:
+            return [SlotSet("contacts_list", None)]

rasa/cli/project_templates/finance/actions/contacts/remove_contact.py

@@ -0,0 +1,35 @@
+from typing import Any, Dict, List
+
+from rasa_sdk import Action, Tracker
+from rasa_sdk.events import SlotSet
+from rasa_sdk.executor import CollectingDispatcher
+
+from actions.db import get_contacts, write_contacts
+
+
+class RemoveContact(Action):
+    def name(self) -> str:
+        return "remove_contact"
+
+    def run(
+        self, dispatcher: CollectingDispatcher, tracker: Tracker, domain: Dict[str, Any]
+    ) -> List[Dict[str, Any]]:
+        contacts = get_contacts(tracker.sender_id)
+        handle = tracker.get_slot("remove_contact_handle")
+
+        if handle is not None:
+            contact_indices_with_handle = [
+                i for i, c in enumerate(contacts) if c.handle == handle
+            ]
+            if len(contact_indices_with_handle) == 0:
+                return [SlotSet("return_value", "not_found")]
+            else:
+                removed_contact = contacts.pop(contact_indices_with_handle[0])
+                write_contacts(tracker.sender_id, contacts)
+                return [
+                    SlotSet("return_value", "success"),
+                    SlotSet("remove_contact_name", removed_contact.name),
+                ]
+
+        else:
+            return [SlotSet("return_value", "missing_handle")]

rasa/cli/project_templates/finance/actions/db.py

@@ -0,0 +1,117 @@
+import os
+import shutil
+import tempfile
+from typing import Any, List
+
+from pydantic import BaseModel
+
+from rasa.nlu.utils import write_json_to_file
+from rasa.shared.utils.io import read_json_file
+
+ORIGIN_DB_PATH = "db"
+CONTACTS = "contacts.json"
+TRANSACTIONS = "transactions.json"
+MY_ACCOUNT = "my_account.json"
+CARDS = "cards.json"
+
+
+class MyAccount(BaseModel):
+    account: str
+    funds: int
+    daily_limit: int
+    monthly_limit: int
+
+
+class Transaction(BaseModel):
+    datetime: str
+    recipient: str
+    sender: str
+    amount: str
+    description: str
+
+    def stringify(self) -> str:
+        from datetime import datetime
+
+        parsed_date = datetime.strptime(self.datetime, "%Y-%m-%dT%H:%M:%S.%f")
+        formatted_date = parsed_date.strftime("%Y-%m-%d %H:%M:%S")
+
+        return (
+            f"- {self.amount} from {self.sender} to "
+            f"{self.recipient}: {self.description} ({formatted_date})"
+        )
+
+
+class Contact(BaseModel):
+    name: str
+    handle: str
+
+
+class Card(BaseModel):
+    name: str
+    number: str
+    expiration_date: str
+    cvv: str
+    handle: str
+    status: str
+
+
+def get_session_db_path(session_id: str) -> str:
+    tempdir = tempfile.gettempdir()
+    project_name = "rasa-calm-demo"
+    return os.path.join(tempdir, project_name, session_id)
+
+
+def prepare_db_file(session_id: str, db: str) -> str:
+    session_db_path = get_session_db_path(session_id)
+    os.makedirs(session_db_path, exist_ok=True)
+    destination_file = os.path.join(session_db_path, db)
+    if not os.path.exists(destination_file):
+        origin_file = os.path.join(ORIGIN_DB_PATH, db)
+        shutil.copy(origin_file, destination_file)
+    return destination_file
+
+
+def read_db(session_id: str, db: str) -> Any:
+    db_file = prepare_db_file(session_id, db)
+    return read_json_file(db_file)
+
+
+def write_db(session_id: str, db: str, data: Any) -> None:
+    db_file = prepare_db_file(session_id, db)
+    write_json_to_file(db_file, data)
+
+
+def get_contacts(session_id: str) -> List[Contact]:
+    return [Contact(**item) for item in read_db(session_id, CONTACTS)]
+
+
+def get_cards(session_id: str) -> List[Card]:
+    return [Card(**item) for item in read_db(session_id, CARDS)]
+
+
+def get_transactions(session_id: str) -> List[Transaction]:
+    return [Transaction(**item) for item in read_db(session_id, TRANSACTIONS)]
+
+
+def get_account(session_id: str) -> MyAccount:
+    return MyAccount(**read_db(session_id, MY_ACCOUNT))
+
+
+def write_account(session_id: str, account: MyAccount) -> None:
+    write_db(session_id, MY_ACCOUNT, account.dict())
+
+
+def add_contact(session_id: str, contact: Contact) -> None:
+    contacts = get_contacts(session_id)
+    contacts.append(contact)
+    write_db(session_id, CONTACTS, [c.dict() for c in contacts])
+
+
+def add_transaction(session_id: str, transaction: Transaction) -> None:
+    transactions = get_transactions(session_id)
+    transactions.append(transaction)
+    write_db(session_id, TRANSACTIONS, [t.dict() for t in transactions])
+
+
+def write_contacts(session_id: str, contacts: List[Contact]) -> None:
+    write_db(session_id, CONTACTS, [c.dict() for c in contacts])

rasa/cli/project_templates/finance/actions/general/action_human_handoff.py

@@ -0,0 +1,49 @@
+from typing import Any, Dict, List, Text
+
+from openai import AsyncOpenAI
+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 __init__(self) -> None:
+        super().__init__()
+        self.client = AsyncOpenAI()
+
+    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 = "{}".format(event.get("text"))
+                user_text2 = "user - " + user_text
+                convo.append(user_text2)
+            if event.get("event") == "bot":
+                bot_text = "{}".format(event.get("text"))
+                bot_text2 = "bot - " + bot_text
+                # print(bot_text)
+                convo.append(bot_text2)
+        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 = await self.client.chat.completions.create(
+            model="gpt-4",  # or "gpt-3.5-turbo"
+            messages=[{"role": "user", "content": prompt}],
+        )
+        summarised_conversation = response.choices[0].message.content or ""
+        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/finance/actions/transfers/check_transfer_funds.py

@@ -0,0 +1,27 @@
+import re
+from typing import Any, Dict, List
+
+from rasa_sdk import Action, Tracker
+from rasa_sdk.events import SlotSet
+from rasa_sdk.executor import CollectingDispatcher
+
+from actions.db import get_account
+
+
+class CheckTransferFunds(Action):
+    def name(self) -> str:
+        return "check_transfer_funds"
+
+    def run(
+        self, dispatcher: CollectingDispatcher, tracker: Tracker, domain: Dict[str, Any]
+    ) -> List[Dict[str, Any]]:
+        account = get_account(tracker.sender_id)
+        amount_of_money = tracker.get_slot("amount_of_money")
+        if not amount_of_money:
+            has_sufficient_funds = False
+        else:
+            if isinstance(amount_of_money, str):
+                # Remove any non-numeric characters (except for the decimal point)
+                amount_of_money = float(re.sub(r"[^0-9.]", "", amount_of_money))
+            has_sufficient_funds = account.funds >= amount_of_money
+        return [SlotSet("has_sufficient_funds", has_sufficient_funds)]

rasa/cli/project_templates/finance/actions/transfers/check_transfer_limit.py

@@ -0,0 +1,36 @@
+from typing import Any, Dict, List, Text
+
+from rasa_sdk import Action, Tracker
+from rasa_sdk.events import SlotSet
+from rasa_sdk.executor import CollectingDispatcher
+
+from actions.db import get_account
+
+
+class CheckTransferLimit(Action):
+    def name(self) -> Text:
+        return "check_transfer_limit"
+
+    def run(
+        self,
+        dispatcher: CollectingDispatcher,
+        tracker: Tracker,
+        domain: Dict[Text, Any],
+    ) -> List[Dict[Text, Any]]:
+        limit_type = tracker.get_slot("transfer_limit_type")
+
+        account = get_account(tracker.sender_id)
+        daily_limit = account.daily_limit
+        monthly_limit = account.monthly_limit
+
+        transfer_limit = None
+
+        if limit_type == "daily":
+            transfer_limit = daily_limit
+        elif limit_type == "monthly":
+            transfer_limit = monthly_limit
+
+        return [
+            SlotSet("transfer_limit", transfer_limit),
+            SlotSet("return_value", transfer_limit is not None),
+        ]

rasa/cli/project_templates/finance/actions/transfers/execute_recurrent_payment.py

@@ -0,0 +1,20 @@
+from typing import List
+
+from rasa_sdk import Action, Tracker
+from rasa_sdk.events import EventType, SlotSet
+from rasa_sdk.executor import CollectingDispatcher
+from rasa_sdk.types import DomainDict
+
+
+class ExecutePayment(Action):
+    def name(self) -> str:
+        return "action_execute_recurrent_payment"
+
+    def run(
+        self,
+        dispatcher: CollectingDispatcher,
+        tracker: Tracker,
+        domain: DomainDict,
+    ) -> List[EventType]:
+        # Set-up payment logic and additional checks here
+        return [SlotSet("setup_recurrent_payment_successful", True)]

rasa/cli/project_templates/finance/actions/transfers/execute_transfer.py

@@ -0,0 +1,45 @@
+import re
+from datetime import datetime
+from typing import Any, Dict, List
+
+from rasa_sdk import Action, Tracker
+from rasa_sdk.events import SlotSet
+from rasa_sdk.executor import CollectingDispatcher
+
+from actions.db import Transaction, add_transaction, get_account, write_account
+
+AMOUNT_OF_MONEY_REGEX = re.compile(r"\d*[.,]*\d+")
+
+
+class ExecuteTransfer(Action):
+    def name(self) -> str:
+        return "execute_transfer"
+
+    def run(
+        self, dispatcher: CollectingDispatcher, tracker: Tracker, domain: Dict[str, Any]
+    ) -> List[Dict[str, Any]]:
+        account = get_account(tracker.sender_id)
+
+        recipient = tracker.get_slot("recipient_account")
+        amount_of_money = tracker.get_slot("amount_of_money")
+
+        if recipient is None or amount_of_money is None:
+            return [SlotSet("transfer_successful", False)]
+
+        # just as a play case
+        if recipient == "Jack":
+            return [SlotSet("transfer_successful", False)]
+
+        if isinstance(amount_of_money, str):
+            amount_of_money = float(re.sub(r"[^0-9.]", "", amount_of_money))
+        account.funds -= amount_of_money
+        new_transaction = Transaction(
+            datetime=datetime.now().isoformat(),
+            recipient=recipient or "unknown",
+            sender="self",
+            amount=str(amount_of_money),
+            description="",
+        )
+        add_transaction(tracker.sender_id, new_transaction)
+        write_account(tracker.sender_id, account)
+        return [SlotSet("transfer_successful", True)]

rasa/cli/project_templates/finance/actions/transfers/list_transactions.py

@@ -0,0 +1,32 @@
+from datetime import datetime
+from typing import Any, Dict, List
+
+from rasa_sdk import Action, Tracker
+from rasa_sdk.events import SlotSet
+from rasa_sdk.executor import CollectingDispatcher
+
+from actions.db import get_transactions
+
+
+class ListTransactions(Action):
+    def name(self) -> str:
+        return "list_transactions"
+
+    def run(
+        self, dispatcher: CollectingDispatcher, tracker: Tracker, domain: Dict[str, Any]
+    ) -> List[Dict[str, Any]]:
+        full_transaction_list = tracker.get_slot("full_transaction_list")
+
+        transactions = get_transactions(tracker.sender_id)
+
+        # sort by date
+        transactions.sort(
+            key=lambda x: datetime.strptime(x.datetime, "%Y-%m-%dT%H:%M:%S.%f"),
+            reverse=True,
+        )
+
+        if not full_transaction_list:
+            transactions = transactions[:5]
+
+        transactions_list = "\n".join([t.stringify() for t in transactions])
+        return [SlotSet("transactions_list", transactions_list)]