rasa-pro 3.14.0.dev4__py3-none-any.whl → 3.14.0.dev5__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,132 @@
+"""Functions for training and loading Rasa models."""
+
+import os
+import tempfile
+
+import structlog
+
+from rasa.builder import config
+from rasa.builder.exceptions import AgentLoadError, TrainingError
+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
+from rasa.shared.utils.yaml import dump_obj_as_yaml_to_string
+
+structlogger = structlog.get_logger()
+
+
+async def train_and_load_agent(importer: TrainingDataImporter) -> agent.Agent:
+    """Train a model and load an agent.
+
+    Args:
+        importer: Training data importer with domain, flows, and config
+
+    Returns:
+        Loaded and ready agent
+
+    Raises:
+        TrainingError: If training fails
+        AgentLoadError: If agent loading fails
+    """
+    try:
+        # Setup endpoints for training validation
+        await _setup_endpoints()
+
+        # Train the model
+        training_result = await _train_model(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() -> None:
+    """Setup endpoints configuration for training."""
+    try:
+        with tempfile.NamedTemporaryFile(
+            mode="w", suffix=".yml", delete=False
+        ) as temp_file:
+            endpoints_yaml = dump_obj_as_yaml_to_string(config.get_default_endpoints())
+            temp_file.write(endpoints_yaml)
+            temp_file.flush()
+
+            # Reset and load endpoints
+            AvailableEndpoints.reset_instance()
+            read_endpoints_from_path(temp_file.name)
+
+            structlogger.debug("training.endpoints_setup", temp_file=temp_file.name)
+
+    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,93 @@
+"""Functions for validating Rasa projects."""
+
+import sys
+from contextlib import contextmanager
+from typing import Any, Dict, Generator, Optional
+
+import structlog
+from structlog.testing import capture_logs
+
+from rasa.builder import config
+from rasa.builder.exceptions import ValidationError
+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
+    """
+    try:
+        with _mock_sys_exit() as exit_tracker:
+            with capture_logs() as cap_logs:
+                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 cap_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 cap_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 cap_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/arguments/default_arguments.py

@@ -3,7 +3,6 @@ import logging
 from enum import Enum
 from typing import List, Optional, Text, Union
 
-from rasa.core.constants import DEFAULT_SUB_AGENTS
 from rasa.core.persistor import RemoteStorageType, StorageType, parse_remote_storage
 from rasa.shared.constants import (
     DEFAULT_CONFIG_PATH,
@@ -218,14 +217,3 @@ def add_skip_validation_flag(
         action="append",
         help="Skip YAML validation for selected parts of the training data.",
     )
-
-
-def add_sub_agents_param(
-    parser: Union[argparse.ArgumentParser, argparse._ActionsContainer],
-) -> None:
-    parser.add_argument(
-        "--sub-agents",
-        type=str,
-        default=DEFAULT_SUB_AGENTS,
-        help="Directory that specifies sub-agents to use (default: %(default)s).",
-    )

rasa/cli/arguments/run.py

@@ -7,7 +7,6 @@ from rasa.cli.arguments.default_arguments import (
     add_model_param,
     add_remote_storage_param,
     add_skip_validation_flag,
-    add_sub_agents_param,
 )
 from rasa.core import constants
 from rasa.env import (
@@ -25,7 +24,6 @@ def set_run_arguments(parser: argparse.ArgumentParser) -> None:
     add_server_arguments(parser)
     add_inspect_argument(parser)
     add_skip_validation_flag(parser)
-    add_sub_agents_param(parser)
 
 
 def set_run_action_arguments(parser: argparse.ArgumentParser) -> None:

rasa/cli/dialogue_understanding_test.py

@@ -14,7 +14,6 @@ from rasa.cli.arguments.default_arguments import (
     add_endpoint_param,
     add_model_param,
     add_remote_storage_param,
-    add_sub_agents_param,
 )
 from rasa.core.agent import Agent
 from rasa.core.available_endpoints import AvailableEndpoints
@@ -175,8 +174,6 @@ def add_du_test_arguments(parser: argparse.ArgumentParser) -> None:
         ),
     )
 
-    add_sub_agents_param(du_arguments)
-
 
 def ensure_calm_only_bot(agent: Agent) -> None:
     if agent.domain is None or agent.processor is None:
@@ -221,7 +218,6 @@ def execute_dialogue_understanding_tests(args: argparse.Namespace) -> None:
             model_path=args.model,
             model_server=endpoints.model,
             remote_storage=args.remote_storage,
-            sub_agents_path=args.sub_agents,
         )
     except AgentNotReady as error:
         structlogger.error(

rasa/cli/e2e_test.py

@@ -17,7 +17,6 @@ from rasa.cli.arguments.default_arguments import (
     add_endpoint_param,
     add_model_param,
     add_remote_storage_param,
-    add_sub_agents_param,
 )
 from rasa.core.available_endpoints import AvailableEndpoints
 from rasa.core.exceptions import AgentNotReady
@@ -148,8 +147,6 @@ def add_e2e_test_arguments(parser: argparse.ArgumentParser) -> None:
         help="Directory where to save coverage report to.",
     )
 
-    add_sub_agents_param(parser)
-
 
 def execute_e2e_tests(args: argparse.Namespace) -> None:
     """Run the end-to-end tests.
@@ -195,7 +192,6 @@ def execute_e2e_tests(args: argparse.Namespace) -> None:
             model_server=endpoints.model,
             endpoints=endpoints,
             test_case_path=Path(test_case_path),
-            sub_agents_path=args.sub_agents,
         )
     except AgentNotReady as error:
         structlogger.error(