rasa-pro 3.14.0.dev20250825__py3-none-any.whl → 3.14.0.dev20250901__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/skill_to_bot_prompt.jinja2

@@ -0,0 +1,164 @@
+# Rasa CALM Flow and Domain YAML Generator
+
+You are an expert in creating Rasa CALM flows and domain JSON configurations. Your task is to generate these JSON files based on a user's description of a conversational skill. The user may not be familiar with Rasa, so it's crucial to interpret their requirements accurately and create a well-structured, functional Rasa configuration.
+
+## Input
+You will receive a description of a conversational skill. This description will be inserted where you see [USER_SKILL_DESCRIPTION] in this prompt.
+
+## Output
+Generate a JSON configurations that includes:
+1. A Rasa CALM flow JSON
+2. A corresponding Rasa domain JSON
+
+Ensure that both parts of the JSONs are complete, well-structured, and compatible with each other.
+
+## Example
+Here's an example of a skill description and the corresponding JSON outputs and custom action code
+
+Skill Description: "Create a skill for transferring money. It should ask for the recipient and amount, check the user has enough balance, and then confirm with the user before finalizing the transfer."
+
+CALM BOT JSON:
+```json
+{
+  "flows": {
+    "transfer_money": {
+      "description": "This flow lets users send money to friends and family.",
+      "steps": [
+        {
+          "collect": "recipient"
+        },
+        {
+          "collect": "amount",
+          "description": "the number of US dollars to send"
+        },
+        {
+          "action": "action_check_sufficient_funds",
+          "next": [
+            {
+              "if": "not slots.has_sufficient_funds",
+              "then": [
+                {
+                  "action": "utter_insufficient_funds",
+                  "next": "END"
+                }
+              ]
+            },
+            {
+              "else": "final_confirmation"
+            }
+          ]
+        },
+        {
+          "collect": "final_confirmation",
+          "id": "final_confirmation",
+          "next": [
+            {
+              "if": "not slots.final_confirmation",
+              "then": [
+                {
+                  "action": "utter_transfer_cancelled",
+                  "next": "END"
+                }
+              ]
+            },
+            {
+              "else": "transfer_successful"
+            }
+          ]
+        },
+        {
+          "action": "utter_transfer_complete",
+          "id": "transfer_successful"
+        }
+      ]
+    }
+  },
+  "domain": {
+    "actions": [
+      "action_check_sufficient_funds"
+    ],
+    "slots": {
+      "recipient": {
+        "type": "Text",
+        "mappings": [
+          {
+            "type": "from_llm"
+          }
+        ]
+      },
+      "has_sufficient_funds": {
+        "type": "bool",
+        "mappings": [
+          {
+            "type": "custom"
+          }
+        ]
+      }
+    },
+    "responses": {
+      "utter_ask_recipient": [
+        {
+          "text": "Who would you like to send money to?"
+        }
+      ],
+      "utter_ask_final_confirmation": [
+        {
+          "text": "Please confirm: you want to transfer {amount} to {recipient}?"
+        }
+      ],
+      "utter_transfer_cancelled": [
+        {
+          "text": "Your transfer has been cancelled."
+        }
+      ],
+      "utter_insufficient_funds": [
+        {
+          "text": "You do not have enough funds to make this transaction."
+        }
+      ]
+    }
+  }
+}
+```
+
+## Guidelines for CALM Flow JSON:
+- Start a `flow` with the name of the flow as the key in `flows`
+- Include a `description` for the skill
+- Use `steps` to outline the conversation flow
+- Implement `collect` steps for gathering information
+- `collect` steps should reference an existing slot
+- For a collect step referencing a slot `A`, there should be a corresponding `utter_ask_A`
+  utterance that is used in the collect step to ask for the information to be stored in `A`
+- Use `action` steps for custom actions
+- Implement conditional logic with `if`, `then`, and `else` where appropriate
+- Use `next` to define the flow between steps. If the flow should end after a step, add next: END.
+- The content after `then` or `else` can be: the id of another step defined in the flow, a list of steps, or an END
+- End the flow with an appropriate action or message
+
+## Guidelines for Domain JSON:
+- Include all necessary `actions`
+- Define all required `slots` with appropriate types. Type should be one of 'float', 'bool', 'text', or 'categorical'
+- Slots filled by a 'collect' step should have mapping 'from_llm' and slots set by custom actions should have a 'custom' mapping
+- Provide `responses` for all bot turns
+
+## Guidelines for Custom Actions
+- Ensure all actions mentioned in the flow are properly defined in the domains list of actions.
+
+## Important Notes:
+- Ensure that the flow logic is coherent and follows a natural conversation pattern
+- All custom actions in the flow should be listed in the domain's `actions` section
+- All slots collected in the flow should be defined in the domain's `slots` section
+- Provide appropriate `utter_` responses for each user interaction
+- Use realistic and appropriate names for actions, slots, and responses
+- Consider error handling and alternative conversation paths
+- Aim for a balance between simplicity and functionality
+
+Now, please generate Rasa CALM flow and domain JSON based on the initial bot data.
+Modify the initial bot data where it makes sense based on the users description
+of the skill (e.g. the initial bot greeting utter_greet).
+
+INITIAL BOT DATA:
+{{project_data|tojson}}
+
+USER_SKILL_DESCRIPTION:
+{{skill_description}}

rasa/builder/training_service.py

@@ -0,0 +1,124 @@
+"""Functions for training and loading Rasa models."""
+
+import os
+from pathlib import Path
+
+import structlog
+
+from rasa.builder.exceptions import AgentLoadError, TrainingError
+from rasa.builder.models import TrainingInput
+from rasa.core import agent
+from rasa.core.utils import AvailableEndpoints, read_endpoints_from_path
+from rasa.model_training import TrainingResult, train
+from rasa.shared.importers.importer import TrainingDataImporter
+
+structlogger = structlog.get_logger()
+
+
+async def train_and_load_agent(input: TrainingInput) -> agent.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 _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.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 agent.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/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/config.yml

@@ -0,0 +1,27 @@
+# Rasa Assistant Configuration
+# This file controls your assistant'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 assistant project unique identifier
+# This default value must be replaced with a unique assistant 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
+  check_relevancy: true