rasa-pro 3.14.0.dev7__py3-none-any.whl → 3.14.0.dev9__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/template_cache.py

@@ -0,0 +1,244 @@
+import asyncio
+import os
+import shutil
+import tarfile
+import tempfile
+from pathlib import Path
+from typing import Generator
+
+import aiofiles
+import aiohttp
+import structlog
+from sanic import Sanic
+
+import rasa.version
+from rasa.builder.logging_utils import capture_exception_with_context
+from rasa.cli.scaffold import ProjectTemplateName
+
+structlogger = structlog.get_logger()
+
+CACHE_BUCKET_URL = "https://trained-templates.s3.us-east-1.amazonaws.com"
+
+# Root directory for storing downloaded template caches on disk.
+_CACHE_ROOT_DIR = Path(
+    os.getenv(
+        "RASA_TEMPLATE_CACHE_DIR",
+        Path.home().joinpath(".rasa", "template-cache").as_posix(),
+    )
+)
+
+
+def _template_cache_dir(template: ProjectTemplateName) -> Path:
+    """Return the local cache directory for a given template and version."""
+    return _CACHE_ROOT_DIR / rasa.version.__version__ / template.value
+
+
+def _cache_root_dir() -> Path:
+    return Path(
+        os.getenv(
+            "RASA_TEMPLATE_CACHE_DIR",
+            Path.home().joinpath(".rasa", "template-cache").as_posix(),
+        )
+    )
+
+
+def _safe_tar_members(
+    tar: tarfile.TarFile, destination_directory: Path
+) -> Generator[tarfile.TarInfo, None, None]:
+    """Yield safe members for extraction to prevent path traversal and links.
+
+    Args:
+        tar: Open tar file handle
+        destination_directory: Directory to which files will be extracted
+
+    Yields:
+        Members that are safe to extract within destination_directory
+    """
+    base_path = destination_directory.resolve()
+
+    for member in tar.getmembers():
+        name = member.name
+        # Skip empty names and absolute paths
+        if not name or name.startswith("/") or name.startswith("\\"):
+            continue
+
+        # Disallow symlinks and hardlinks
+        if member.issym() or member.islnk():
+            continue
+
+        # Compute the final path and ensure it's within base_path
+        target_path = (base_path / name).resolve()
+        try:
+            target_path.relative_to(base_path)
+        except ValueError:
+            # Member would escape the destination directory
+            continue
+
+        yield member
+
+
+def _copytree(src: Path, dst: Path) -> None:
+    """Copy directory tree from src to dst, merging into dst.
+
+    Existing files are overwritten. Hidden files and directories are included, as
+    caches can contain `.rasa` metadata that should be applied before calling
+    `ensure_first_used`.
+    """
+    for root, dirs, files in os.walk(src):
+        rel_path = Path(root).relative_to(src)
+        target_dir = dst / rel_path
+        target_dir.mkdir(parents=True, exist_ok=True)
+        for filename in files:
+            src_file = Path(root) / filename
+            dst_file = target_dir / filename
+            shutil.copy2(src_file, dst_file)
+
+
+async def download_cache_for_template(
+    template: ProjectTemplateName, target_dir: str
+) -> None:
+    # get a temp path for the cache file download
+    temporary_cache_file = tempfile.NamedTemporaryFile(suffix=".tar.gz", delete=False)
+
+    try:
+        url = f"{CACHE_BUCKET_URL}/{rasa.version.__version__}-{template.value}.tar.gz"
+        async with aiohttp.ClientSession() as session:
+            async with session.get(url) as response:
+                response.raise_for_status()
+                async with aiofiles.open(temporary_cache_file.name, "wb") as f:
+                    async for chunk in response.content.iter_chunked(1024 * 1024):
+                        await f.write(chunk)
+
+        # extract the cache to the project folder using safe member filtering
+        with tarfile.open(temporary_cache_file.name, "r:gz") as tar:
+            destination = Path(target_dir)
+            destination.mkdir(parents=True, exist_ok=True)
+            tar.extractall(
+                path=destination,
+                members=_safe_tar_members(tar, destination),
+            )
+
+        structlogger.info(
+            "project_generator.download_cache_for_template.success",
+            template=template,
+            event_info=(
+                "Downloaded cache for template, extracted to target directory."
+            ),
+            target_dir=target_dir,
+        )
+    except aiohttp.ClientResponseError as e:
+        if e.status == 403:
+            structlogger.debug(
+                "project_generator.download_cache_for_template.no_cache_found",
+                template=template,
+                event_info=("No cache found for template, continuing without it."),
+                target_dir=target_dir,
+            )
+        else:
+            capture_exception_with_context(
+                e,
+                "project_generator.download_cache_for_template.response_error",
+                extra={
+                    "template": template.value,
+                    "status": str(e.status),
+                    "target_dir": target_dir,
+                },
+            )
+    except Exception as exc:
+        capture_exception_with_context(
+            exc,
+            "project_generator.download_cache_for_template.unexpected_error",
+            extra={"template": template.value, "target_dir": target_dir},
+        )
+    finally:
+        # Clean up the temporary file
+        try:
+            Path(temporary_cache_file.name).unlink(missing_ok=True)
+        except Exception as exc:
+            structlogger.debug(
+                "project_generator.download_cache_for_template.cleanup_error",
+                error=str(exc),
+                template=template,
+                event_info=("Failed to cleanup cache for template, ignoring."),
+            )
+
+
+async def background_download_template_caches(
+    app: Sanic, loop: asyncio.AbstractEventLoop
+) -> None:
+    """Kick off background downloads of template caches if enabled."""
+    try:
+        structlogger.info(
+            "builder.main.background_cache_download.start",
+            event_info=(
+                "Starting background download of template caches for this " "version"
+            ),
+        )
+
+        # Ensure cache root exists
+        _cache_root_dir().mkdir(parents=True, exist_ok=True)
+
+        async def _download(template: ProjectTemplateName) -> None:
+            try:
+                target_dir = _template_cache_dir(template)
+                if target_dir.exists() and any(target_dir.iterdir()):
+                    structlogger.debug(
+                        "builder.main.background_cache_download.skipped",
+                        template=template,
+                        event_info=(
+                            "Skipping download of template cache because it "
+                            "already exists."
+                        ),
+                        target_dir=target_dir,
+                    )
+                    return
+
+                target_dir.mkdir(parents=True, exist_ok=True)
+                await download_cache_for_template(template, target_dir.as_posix())
+            except Exception as exc:
+                structlogger.debug(
+                    "builder.main.background_cache_download.error",
+                    template=template,
+                    error=str(exc),
+                )
+
+        # schedule downloads concurrently without blocking startup
+        for template in ProjectTemplateName:
+            loop.create_task(_download(template))
+    except Exception as exc:
+        structlogger.debug(
+            "builder.main.background_cache_download.unexpected_error",
+            error=str(exc),
+        )
+
+
+def copy_cache_for_template_if_available(
+    template: ProjectTemplateName, project_folder: Path
+) -> None:
+    """Copy a previously downloaded cache for `template` into `project_folder`.
+
+    If the cache does not exist, this function is a no-op.
+    """
+    try:
+        cache_dir = _template_cache_dir(template)
+        if cache_dir.exists() and any(cache_dir.iterdir()):
+            _copytree(cache_dir, project_folder)
+            structlogger.info(
+                "project_generator.copy_cache_for_template.success",
+                template=template,
+                event_info=(
+                    "Copied cached template files from cache to project folder."
+                ),
+            )
+        else:
+            structlogger.debug(
+                "project_generator.copy_cache_for_template.missing",
+                template=template,
+                event_info=("No local cache found for template; skipping copy."),
+            )
+    except Exception as exc:
+        structlogger.warning(
+            "project_generator.copy_cache_for_template.error",
+            error=str(exc),
+            template=template,
+        )