rasa-pro 3.14.0.dev7__py3-none-any.whl → 3.14.0.dev9__py3-none-any.whl

rasa/builder/training_service.py

@@ -0,0 +1,194 @@
+"""Functions for training and loading Rasa models."""
+
+import os
+from pathlib import Path
+from typing import Optional
+
+import structlog
+from sanic import Sanic
+
+from rasa.builder.exceptions import AgentLoadError, TrainingError
+from rasa.builder.models import TrainingInput
+from rasa.core.agent import Agent, load_agent
+from rasa.core.channels.studio_chat import StudioChatInput
+from rasa.core.utils import AvailableEndpoints, read_endpoints_from_path
+from rasa.model import get_latest_model
+from rasa.model_training import TrainingResult, train
+from rasa.shared.importers.importer import TrainingDataImporter
+
+structlogger = structlog.get_logger()
+
+
+def update_agent(agent: Optional[Agent], app: Sanic) -> None:
+    """Update the agent in the request context."""
+    app.ctx.agent = agent
+    if hasattr(app.ctx, "input_channel") and isinstance(
+        app.ctx.input_channel, StudioChatInput
+    ):
+        app.ctx.input_channel.agent = agent
+
+
+async def train_and_load_agent(input: TrainingInput) -> Agent:
+    """Train a model and load an agent.
+
+    Args:
+        input: Training input with importer and endpoints file
+
+    Returns:
+        Loaded and ready agent
+
+    Raises:
+        TrainingError: If training fails
+        AgentLoadError: If agent loading fails
+    """
+    try:
+        # Setup endpoints for training validation
+        await _setup_endpoints(input.endpoints_file)
+
+        # Train the model
+        training_result = await _train_model(input.importer)
+
+        # Load the agent
+        agent_instance = await _load_agent(training_result.model)
+
+        # Verify agent is ready
+        if not agent_instance.is_ready():
+            raise AgentLoadError("Agent failed to load properly - model is not ready")
+
+        structlogger.info("training.agent_ready", model_path=training_result.model)
+
+        return agent_instance
+
+    except (TrainingError, AgentLoadError):
+        raise
+    except Exception as e:
+        raise TrainingError(f"Unexpected error during training: {e}")
+    except SystemExit as e:
+        raise TrainingError(f"SystemExit during training: {e}")
+
+
+async def try_load_existing_agent(project_folder: str) -> Optional[Agent]:
+    """Try to load an existing agent from the project's models directory.
+
+    Args:
+        project_folder: Path to the project folder
+
+    Returns:
+        Loaded Agent instance if successful, None otherwise
+    """
+    models_dir = os.path.join(project_folder, "models")
+
+    if not os.path.exists(models_dir) or not os.path.isdir(models_dir):
+        structlogger.debug("No models directory found", models_dir=models_dir)
+        return None
+
+    try:
+        # Find the latest model in the models directory
+        latest_model_path = get_latest_model(models_dir)
+        if not latest_model_path:
+            structlogger.debug(
+                "No models found in models directory", models_dir=models_dir
+            )
+            return None
+
+        structlogger.info(
+            "Found existing model, attempting to load", model_path=latest_model_path
+        )
+
+        # Get available endpoints for agent loading
+        available_endpoints = AvailableEndpoints.get_instance()
+
+        # Load the agent
+        agent = await load_agent(
+            model_path=latest_model_path, endpoints=available_endpoints
+        )
+
+        if agent and agent.is_ready():
+            structlogger.info(
+                "Successfully loaded existing agent", model_path=latest_model_path
+            )
+            return agent
+        else:
+            structlogger.warning(
+                "Agent loaded but not ready", model_path=latest_model_path
+            )
+            return None
+
+    except Exception as e:
+        structlogger.warning(
+            "Failed to load existing agent",
+            models_dir=models_dir,
+            error=str(e),
+            exc_info=True,
+        )
+        return None
+
+
+async def _setup_endpoints(endpoints_file: Path) -> None:
+    """Setup endpoints configuration for training."""
+    try:
+        # Reset and load endpoints
+        AvailableEndpoints.reset_instance()
+        read_endpoints_from_path(endpoints_file)
+
+        structlogger.debug("training.endpoints_setup", endpoints_file=endpoints_file)
+
+    except Exception as e:
+        raise TrainingError(f"Failed to setup endpoints: {e}")
+
+
+async def _train_model(importer: TrainingDataImporter) -> TrainingResult:
+    """Train the Rasa model."""
+    try:
+        structlogger.info("training.started")
+
+        training_result = await train(
+            domain="",
+            config="",
+            training_files=None,
+            file_importer=importer,
+        )
+
+        if not training_result or not training_result.model:
+            raise TrainingError("Training completed but no model was produced")
+
+        structlogger.info("training.completed", model_path=training_result.model)
+
+        return training_result
+
+    except Exception as e:
+        raise TrainingError(f"Model training failed: {e}")
+
+
+async def _load_agent(model_path: str) -> Agent:
+    """Load the trained agent."""
+    try:
+        structlogger.info("training.loading_agent", model_path=model_path)
+
+        available_endpoints = AvailableEndpoints.get_instance()
+        if available_endpoints is None:
+            raise AgentLoadError("No endpoints available for agent loading")
+
+        structlogger.debug(
+            "training.loading_agent.cwd",
+            cwd=os.getcwd(),
+            model_path=model_path,
+        )
+
+        agent_instance = await load_agent(
+            model_path=model_path,
+            remote_storage=None,
+            endpoints=available_endpoints,
+        )
+
+        if agent_instance is None:
+            raise AgentLoadError("Agent loading returned None")
+
+        structlogger.info("training.agent_loaded", model_path=model_path)
+
+        return agent_instance
+
+    except AgentLoadError:
+        raise
+    except Exception as e:
+        raise AgentLoadError(f"Failed to load agent: {e}")

rasa/builder/validation_service.py

@@ -0,0 +1,97 @@
+"""Functions for validating Rasa projects."""
+
+import sys
+from contextlib import contextmanager
+from typing import Any, Dict, Generator, Optional
+
+import structlog
+
+from rasa.builder import config
+from rasa.builder.exceptions import ValidationError
+from rasa.builder.logging_utils import capture_validation_logs
+from rasa.cli.utils import validate_files
+from rasa.shared.importers.importer import TrainingDataImporter
+
+structlogger = structlog.get_logger()
+
+
+@contextmanager
+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) -> None:
+        was_sys_exit_called["value"] = True
+
+    original_exit = sys.exit
+    sys.exit = sys_exit_mock  # type: ignore[assignment]
+
+    try:
+        yield was_sys_exit_called
+    finally:
+        sys.exit = original_exit
+
+
+async def validate_project(importer: TrainingDataImporter) -> Optional[str]:
+    """Validate a Rasa project.
+
+    Args:
+        importer: Training data importer with domain, flows, and config
+
+    Returns:
+        None if validation passes, error message if validation fails.
+
+    Raises:
+        ValidationError: If validation fails
+    """
+    with capture_validation_logs() as captured_logs:
+        try:
+            with _mock_sys_exit() as exit_tracker:
+                validate_files(
+                    fail_on_warnings=config.VALIDATION_FAIL_ON_WARNINGS,
+                    max_history=config.VALIDATION_MAX_HISTORY,
+                    importer=importer,
+                )
+
+                if exit_tracker["value"]:
+                    error_logs = [
+                        log for log in captured_logs if log.get("log_level") != "debug"
+                    ]
+                    structlogger.error(
+                        "validation.failed.sys_exit",
+                        error_logs=error_logs,
+                    )
+                    raise ValidationError(
+                        "Validation failed with sys.exit", validation_logs=error_logs
+                    )
+
+                structlogger.info("validation.success")
+                return None
+
+        except ValidationError:
+            raise
+
+        except Exception as e:
+            error_msg = f"Validation failed with exception: {e}"
+
+            error_logs = [
+                log for log in captured_logs if log.get("log_level") != "debug"
+            ]
+
+            structlogger.error(
+                "validation.failed.exception", error=str(e), validation_logs=error_logs
+            )
+            raise ValidationError(error_msg, validation_logs=error_logs)
+
+        except SystemExit as e:
+            error_logs = [
+                log for log in captured_logs if log.get("log_level") != "debug"
+            ]
+
+            structlogger.error(
+                "validation.failed.sys_exit",
+                error_logs=error_logs,
+            )
+            raise ValidationError(
+                f"SystemExit during validation: {e}", validation_logs=error_logs
+            )

rasa/cli/project_templates/basic/README.md

@@ -0,0 +1,23 @@
+# Basic Rasa Template
+
+A simple, general-purpose conversational agent template that provides essential conversational capabilities.
+
+## 🚀 What's Included
+
+This template provides a foundation for building conversational agents with:
+- **Basic conversational flows**: Greetings, help, feedback, and human handoff
+- **Help system**: Users can ask for assistance and get guided responses
+- **Feedback collection**: Gather user feedback to improve the agent
+- **Human handoff**: Seamlessly transfer conversations to human agents when needed
+
+## 📁 Directory Structure
+
+```
+├── actions/          # Custom Python logic for agent actions
+├── data/            # Conversational flows and training data
+├── domain/          # Agent configuration (slots, responses, actions)
+├── docs/            # Knowledge base documents (optional)
+├── prompts/         # LLM prompts for enhanced responses
+└── config.yml       # Training pipeline configuration
+```
+

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

@@ -0,0 +1,40 @@
+from typing import Any, Dict, List, Text
+
+import openai
+from rasa_sdk import Action, Tracker
+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]]:
+        convo: List[str] = []
+        for event in tracker.events:
+            if event.get("event") == "user":
+                user_text = str(event.get("text") or "")
+                convo.append(f"user - {user_text}")
+            elif event.get("event") == "bot":
+                bot_text = str(event.get("text") or "")
+                convo.append(f"bot - {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 the "
+            f"important context. Conversation: "
+            f"{convo}"
+        )
+        response = openai.chat.completions.create(
+            model="gpt-4o",
+            messages=[{"role": "user", "content": prompt}],
+        )
+        summarised_conversation = (
+            response.choices[0].message.content or "No summary available"
+        )
+        dispatcher.utter_message(
+            response="utter_transfer_to_manager", summary=summarised_conversation
+        )
+        return []

rasa/cli/project_templates/basic/actions/actions.md

@@ -0,0 +1,10 @@
+## 📂 `actions/` – The Agent's Toolkit
+
+This folder contains Python files that define custom actions your agent can perform. Actions are pieces of code that run when your agent needs to do something beyond just responding with text.
+
+**What you'll find:**
+- `action_human_handoff.py`: Handles transferring the conversation to a human agent when needed.
+
+**Edit Python files in this folder** to add new custom logic, integrate with APIs, or perform calculations and data processing.
+
+Learn more about custom actions in the [Rasa documentation](https://rasa.com/docs/pro/build/custom-actions).

rasa/cli/project_templates/basic/config.yml

@@ -0,0 +1,29 @@
+# Rasa Agent Configuration
+# This file controls your agent's language, message processing pipeline, and conversation policies.
+# For full documentation, see: https://rasa.com/docs/pro/build/configuring-assistant
+recipe: default.v1
+language: en
+
+# The agent project unique identifier  
+# This default value must be replaced with a unique agent name within your deployment
+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
+  embeddings:
+    model_group: openai-embeddings
+  check_relevancy: true

rasa/cli/project_templates/basic/credentials.yml

@@ -0,0 +1,33 @@
+# 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
+
+
+#facebook:
+#  verify: "<verify>"
+#  secret: "<your secret>"
+#  page-access-token: "<your page access token>"
+
+#slack:
+#  slack_token: "<your slack token>"
+#  slack_channel: "<the slack channel>"
+#  slack_signing_secret: "<your slack signing secret>"
+
+#socketio:
+#  user_message_evt: <event name for user message>
+#  bot_message_evt: <event name for bot messages>
+#  session_persistence: <true/false>
+
+#mattermost:
+#  url: "https://<mattermost instance>/api/v4"
+#  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/data.md

@@ -0,0 +1,9 @@
+## 📂 `data/` – The agent's Business Logic
+
+This folder holds files that define your agent’s skills using "flows". Each flow is a step-by-step conversation pattern (like a recipe) for handling a user goal (e.g., checking a balance, updating an address).
+
+**What you’ll find:**
+- Each YAML file = one or more skills.
+- Flows are made of steps: collecting info, calling actions, and responding.
+
+**Edit txt files in this folder** to add new skills, change existing flows, or adjust what the agent asks.

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

@@ -0,0 +1,21 @@
+# Simple thumbs up/down feedback flow
+flows:
+  leave_feedback:
+    name: leaving 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,6 @@
+flows:
+  hello:
+    description: Flow for greeting the user hello
+    name: hello
+    steps:
+      - action: utter_hello

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

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

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

@@ -0,0 +1,16 @@
+version: "3.1"
+flows:
+  human_handoff:
+    description: When you are unable to handle the request or the user is frustrated - offers to hand the user over 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/show_faqs.yml

@@ -0,0 +1,6 @@
+flows:
+  show_faqs:
+    description: Show users the most frequently asked questions about Rasa and CALM
+    name: show_faqs
+    steps:
+      - action: utter_top_faqs

rasa/cli/project_templates/basic/data/system/patterns/pattern_cannot_handle.yml

@@ -0,0 +1,7 @@
+# Flow for handling cases where the agent cannot provide a relevant answer
+flows:
+  cannot_handle:
+    description: Handle cases where no relevant answer is found
+    if: False
+    steps:
+      - action: utter_no_relevant_answer_found

rasa/cli/project_templates/basic/data/system/patterns/pattern_completed.yml

@@ -0,0 +1,7 @@
+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/patterns/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/patterns/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/patterns/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:
+      - action: utter_welcome

rasa/cli/project_templates/basic/docs/docs.md

@@ -0,0 +1,5 @@
+## 📂 `docs/` – The Agent's Knowledge Base (optional)
+
+If your agent answers knowledge-based questions (FAQs, policies, etc.), you can put markdown, PDFs, or text files in this folder. Rasa can use this content for retrieval-augmented responses if set up with a vector store [2](https://rasa.com/docs/pro/build/retrieval-actions).
+
+**Edit here** to update what your agent can retrieve and summarize for users.

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

@@ -0,0 +1,28 @@
+1. General Questions
+
+Q: What is Rasa and what can I build with it?
+A: Rasa is a conversational AI framework that lets you build agents using flows and large language models (LLMs). You can create agents for customer support, automation, or any use case that needs reliable, multi-step conversations.
+
+Q: What is CALM in Rasa?
+A: CALM (Conversational AI with Language Models) is Rasa’s architecture for building agents that combine LLM-powered language understanding with deterministic business logic, defined in flows.
+
+Q: What is a flow in Rasa?
+A: A flow is a step-by-step definition of a business process or conversation path. Flows specify what information to collect, what actions to perform, and how to branch or complete the conversation.
+
+Q: How do I customize what my agent asks or does?
+A: You can edit or add flows in the flows.yml file, providing clear descriptions for each flow and for each step. Slot descriptions help the agent extract the right information from the user.
+
+Q: How does Rasa use LLMs?
+A: Rasa uses LLMs to interpret user messages and generate high-level commands. These commands are then executed through flows and actions, ensuring reliable and controlled conversations.
+
+Q: What files are important in a CALM-based Rasa project?
+A: Key files include flows.yml (flows and their descriptions), domain.yml (slots, responses, and actions), and actions.py (custom business logic or integrations).
+
+Q: How do I test my agent?
+A: You can test your agent using the Rasa shell or Rasa Inspector, which lets you interact with your agent and debug flow execution.
+
+Q: Can I extend my agent with custom logic?
+A: Yes, you can implement custom actions in Python in actions.py. These can be used for API calls, database checks, or any other business logic.
+
+Q: Do I need to define intents or entities?
+A: No, with CALM and flows, you do not need to define intents or entities unless you have a specific use case for them.

rasa/cli/project_templates/basic/domain/domain.md

@@ -0,0 +1,8 @@
+## 📂 `domain/` – The Agent's Brain
+
+This folder contains YAML files that define the agent's:
+- **Slots**: The agent's memory (e.g., user's name, account number, address) [1](https://rasa.com/docs/reference/primitives/slots/).
+- **Responses**: The messages your agent can say to users (e.g., greetings, confirmations) [2](https://rasa.com/docs/reference/primitives/responses).
+- **Actions**: Custom logic your agent can run (e.g., checking a balance) [3](https://rasa.com/docs/reference/primitives/custom-actions).
+
+You can organize the domain as one big file or many small ones. Rasa will automatically merge everything during training [1](https://rasa.com/docs/reference/config/domain).

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

@@ -0,0 +1,25 @@
+slots:
+  feedback_rating:
+    type: categorical
+    values: [thumbs_up, thumbs_down]
+    mappings:
+      - type: from_llm
+
+responses:
+  utter_ask_feedback_rating:
+    - text: "We'd love to hear about your experience! How are we doing?"
+      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! We appreciate you taking the time to provide us with feedback. 🌟"
+    - text: "So glad we could help! Thanks for the positive feedback! 😊"
+    - text: "Amazing! We're thrilled you had a great experience. Thank you for your feedback! 🎉"
+
+  utter_thankyou_negative:
+    - text: "We appreciate you taking the time to provide us with feedback. We're always working to improve our service."
+    - text: "Thank you for your honest feedback. We'll use it to make our service better."
+    - text: "Thanks for letting us know. Your feedback helps us improve our agent."

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

@@ -0,0 +1,9 @@
+version: "3.1"
+
+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/hello.yml

@@ -0,0 +1,7 @@
+version: "3.1"
+
+responses:
+  utter_hello:
+    - text: "Hi there! Nice to meet you!"
+      metadata:
+        rephrase: True