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

rasa/builder/shared/tracker_context.py

@@ -1,212 +0,0 @@
-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

@@ -1,164 +0,0 @@
-# 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

@@ -1,132 +0,0 @@
-"""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

@@ -1,93 +0,0 @@
-"""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/project_templates/basic/actions/action_api.py

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

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

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

rasa/cli/project_templates/basic/config.yml

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