rasa-pro 3.13.0.dev20250612__py3-none-any.whl → 3.13.0rc1__py3-none-any.whl

rasa/studio/link.py

@@ -0,0 +1,200 @@
+from __future__ import annotations
+
+import argparse
+import datetime
+import sys
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Text, Union
+
+import questionary
+import structlog
+from pydantic import BaseModel, Field
+
+import rasa.shared.utils.cli
+from rasa.constants import RASA_DIR_NAME
+from rasa.shared.utils.yaml import read_yaml_file, write_yaml
+from rasa.studio.config import StudioConfig
+from rasa.studio.upload import (
+    check_if_assistant_already_exists,
+    handle_upload,
+    is_auth_working,
+)
+
+structlogger = structlog.get_logger(__name__)
+
+_LINK_FILE_NAME: Text = "studio.yml"
+
+
+class AssistantLinkPayload(BaseModel):
+    assistant_name: Text
+    studio_url: Text
+    linked_at: Text = Field(
+        default_factory=lambda: datetime.datetime.utcnow().isoformat() + "Z"
+    )
+
+
+def _link_file(project_root: Path) -> Path:
+    """Return `<project-root>/.rasa/studio.yml`.
+
+    Args:
+        project_root: The path to the project root.
+
+    Returns:
+        The path to the link file.
+    """
+    return project_root / RASA_DIR_NAME / _LINK_FILE_NAME
+
+
+def _write_link_file(
+    project_root: Path, assistant_name: Text, studio_url: Text
+) -> None:
+    """Persist assistant information inside the project.
+
+    Args:
+        project_root: The path to the project root.
+        assistant_name: The name of the assistant.
+        studio_url: The URL of the Rasa Studio instance.
+    """
+    file_path = _link_file(project_root)
+    file_path.parent.mkdir(exist_ok=True, parents=True)
+
+    payload = AssistantLinkPayload(
+        assistant_name=assistant_name,
+        studio_url=studio_url,
+    )
+    write_yaml(payload.model_dump(), file_path)
+
+
+def _read_link_file(
+    project_root: Path = Path.cwd(),
+) -> Optional[Union[List[Any], Dict[Text, Any]]]:
+    """Reads the link configuration file.
+
+    Args:
+        project_root: The path to the project root.
+
+    Returns:
+        The assistant information if the file exists, otherwise None.
+    """
+    file_path = _link_file(project_root)
+    if not file_path.is_file():
+        return None
+
+    return read_yaml_file(file_path)
+
+
+def read_assistant_name(project_root: Path = Path.cwd()) -> Optional[Text]:
+    """Reads the assistant_name from the linked configuration file.
+
+    Args:
+        project_root: The path to the project root.
+
+    Returns:
+        The assistant name if the file exists, otherwise None.
+    """
+    linked = _read_link_file(project_root)
+    assistant_name = (
+        linked.get("assistant_name") if linked and isinstance(linked, dict) else None
+    )
+
+    if not assistant_name:
+        rasa.shared.utils.cli.print_error_and_exit(
+            "This project is not linked to any Rasa Studio assistant.\n"
+            "Run `rasa studio link <assistant-name>` first."
+        )
+
+    return assistant_name
+
+
+def get_studio_config() -> StudioConfig:
+    """Get the StudioConfig object or exit with an error message.
+
+    Returns:
+        A valid StudioConfig object.
+    """
+    config = StudioConfig.read_config()
+    if not config.is_valid():
+        rasa.shared.utils.cli.print_error_and_exit(
+            "Rasa Studio is not configured correctly. Run `rasa studio config` first."
+        )
+    if not is_auth_working(config.studio_url, not config.disable_verify):
+        rasa.shared.utils.cli.print_error_and_exit(
+            "Authentication invalid or expired. Please run `rasa studio login`."
+        )
+    return config
+
+
+def _ensure_assistant_exists(
+    assistant_name: Text,
+    studio_cfg: StudioConfig,
+    args: argparse.Namespace,
+) -> bool:
+    """Create the assistant on Studio if it does not yet exist.
+
+    Args:
+        assistant_name: The name the user provided on the CLI.
+        studio_cfg: The validated Studio configuration.
+        args: The original CLI args (needed for `handle_upload`).
+
+    Returns:
+        True if the assistant already exists or was created, False otherwise.
+    """
+    verify_ssl = not studio_cfg.disable_verify
+    assistant_already_exists = check_if_assistant_already_exists(
+        assistant_name, studio_cfg.studio_url, verify_ssl
+    )
+    if not assistant_already_exists:
+        should_create_assistant = questionary.confirm(
+            f"Assistant '{assistant_name}' was not found on Rasa Studio. "
+            f"Do you want to create it?"
+        ).ask()
+        if should_create_assistant:
+            # `handle_upload` expects the name to live in `args.assistant_name`
+            args.assistant_name = assistant_name
+            handle_upload(args)
+
+            rasa.shared.utils.cli.print_info(
+                f"Assistant {assistant_name} successfully created."
+            )
+        return should_create_assistant
+
+    return assistant_already_exists
+
+
+def handle_link(args: argparse.Namespace) -> None:
+    """Implementation of `rasa studio link <assistant-name>` CLI command.
+
+    Args:
+        args: The command line arguments.
+    """
+    assistant_name: Text = args.assistant_name
+    studio_cfg = get_studio_config()
+    assistant_exists = _ensure_assistant_exists(assistant_name, studio_cfg, args)
+    if not assistant_exists:
+        rasa.shared.utils.cli.print_error_and_exit(
+            "Project has not been linked with Studio assistant."
+        )
+
+    project_root = Path.cwd()
+    link_file = _link_file(project_root)
+
+    if link_file.exists():
+        overwrite = questionary.confirm(
+            f"This project is already linked " f"(link file '{link_file}').\nOverwrite?"
+        ).ask()
+        if not overwrite:
+            rasa.shared.utils.cli.print_info(
+                "Existing link kept – nothing was changed."
+            )
+            sys.exit(0)
+
+    _write_link_file(project_root, assistant_name, studio_cfg.studio_url)
+
+    structlogger.info(
+        "studio.link.success",
+        event_info=f"Project linked to Studio assistant '{assistant_name}'.",
+        assistant_name=assistant_name,
+    )
+    rasa.shared.utils.cli.print_success(
+        f"Project successfully linked to assistant '{assistant_name}'."
+    )

rasa/studio/prompts.py

@@ -0,0 +1,223 @@
+from pathlib import Path
+from typing import Dict, List, Optional, Text
+
+import structlog
+
+from rasa.core.policies.enterprise_search_policy import EnterpriseSearchPolicy
+from rasa.dialogue_understanding.generator.llm_based_command_generator import (
+    LLMBasedCommandGenerator,
+)
+from rasa.shared.constants import (
+    CONFIG_NAME_KEY,
+    CONFIG_PIPELINE_KEY,
+    CONFIG_POLICIES_KEY,
+    DEFAULT_CONFIG_PATH,
+    DEFAULT_ENDPOINTS_PATH,
+    DEFAULT_PROMPTS_PATH,
+    PROMPT_CONFIG_KEY,
+    PROMPT_TEMPLATE_CONFIG_KEY,
+)
+from rasa.shared.utils.common import all_subclasses
+from rasa.shared.utils.llm import get_system_default_prompts
+from rasa.shared.utils.yaml import read_yaml, write_yaml
+from rasa.studio.data_handler import StudioDataHandler
+
+structlogger = structlog.get_logger()
+
+CONTEXTUAL_RESPONSE_REPHRASER_NAME = "contextual_response_rephraser"
+COMMAND_GENERATOR_NAME = "command_generator"
+ENTERPRISE_SEARCH_NAME = "enterprise_search"
+
+
+def handle_prompts(handler: StudioDataHandler, root: Path) -> None:
+    """Handle prompts for the assistant.
+
+    Args:
+        handler: The data handler to retrieve prompts from.
+        root: The root directory where the prompts should be saved.
+    """
+    prompts = handler.get_prompts()
+    if not prompts:
+        return
+
+    config_path = root / DEFAULT_CONFIG_PATH
+    endpoints_path = root / DEFAULT_ENDPOINTS_PATH
+    config: Dict = read_yaml(config_path)
+    endpoints: Dict = read_yaml(endpoints_path)
+
+    system_prompts = get_system_default_prompts(config, endpoints)
+
+    _handle_contextual_response_rephraser(
+        root,
+        prompts.get(CONTEXTUAL_RESPONSE_REPHRASER_NAME),
+        system_prompts.contextual_response_rephraser,
+        endpoints,
+    )
+    _handle_command_generator(
+        root,
+        prompts.get(COMMAND_GENERATOR_NAME),
+        system_prompts.command_generator,
+        config,
+    )
+    _handle_enterprise_search(
+        root,
+        prompts.get(ENTERPRISE_SEARCH_NAME),
+        system_prompts.enterprise_search,
+        config,
+    )
+
+
+def _handle_contextual_response_rephraser(
+    root: Path,
+    prompt_content: Optional[Text],
+    system_prompt: Optional[Text],
+    endpoints: Dict,
+) -> None:
+    """Handles the contextual response rephraser prompt.
+
+    Args:
+        root: The root directory where the prompt file will be saved.
+        prompt_content: The content of the contextual response rephraser prompt.
+        system_prompt: The system prompt for comparison.
+        endpoints: The endpoints configuration to update with the prompt path.
+    """
+    if not _is_custom_prompt(prompt_content, system_prompt):
+        return
+
+    prompt_path = _save_prompt_file(
+        root, f"{CONTEXTUAL_RESPONSE_REPHRASER_NAME}.jinja", prompt_content
+    )
+
+    endpoints["nlg"] = endpoints.get("nlg") or {}
+    endpoints["nlg"]["prompt"] = str(prompt_path)
+
+    endpoints_path = root / DEFAULT_ENDPOINTS_PATH
+    write_yaml(data=endpoints, target=endpoints_path, should_preserve_key_order=True)
+
+
+def _handle_command_generator(
+    root: Path,
+    prompt_content: Optional[Text],
+    system_prompt: Optional[Text],
+    config: Dict,
+) -> None:
+    """Handles the command generator prompt.
+
+    Args:
+        root: The root directory where the prompt file will be saved.
+        prompt_content: The content of the command generator prompt.
+        system_prompt: The system prompt for comparison.
+        config: The configuration dictionary to update with the prompt path.
+    """
+    if not _is_custom_prompt(prompt_content, system_prompt):
+        return
+
+    prompt_path = _save_prompt_file(
+        root, f"{COMMAND_GENERATOR_NAME}.jinja", prompt_content
+    )
+
+    command_generator_names: List[str] = [
+        cls.__name__ for cls in all_subclasses(LLMBasedCommandGenerator)
+    ]
+    _add_prompt_to_config(
+        config=config,
+        section_key=CONFIG_PIPELINE_KEY,
+        component_names=command_generator_names,
+        prompt_key=PROMPT_TEMPLATE_CONFIG_KEY,
+        prompt_path=str(prompt_path),
+    )
+
+    config_path = root / DEFAULT_CONFIG_PATH
+    write_yaml(data=config, target=config_path, should_preserve_key_order=True)
+
+
+def _handle_enterprise_search(
+    root: Path,
+    prompt_content: Optional[Text],
+    system_prompt: Optional[Text],
+    config: Dict,
+) -> None:
+    """Handles the enterprise search prompt.
+
+    Args:
+        root: The root directory where the prompt file will be saved.
+        prompt_content: The content of the enterprise search prompt.
+        system_prompt: The system prompt for comparison.
+        config: The configuration dictionary to update with the prompt path.
+    """
+    if not _is_custom_prompt(prompt_content, system_prompt):
+        return
+
+    prompt_path = _save_prompt_file(
+        root, f"{ENTERPRISE_SEARCH_NAME}.jinja", prompt_content
+    )
+
+    _add_prompt_to_config(
+        config=config,
+        section_key=CONFIG_POLICIES_KEY,
+        component_names=[EnterpriseSearchPolicy.__name__],
+        prompt_key=PROMPT_CONFIG_KEY,
+        prompt_path=str(prompt_path),
+    )
+
+    config_path = root / DEFAULT_CONFIG_PATH
+    write_yaml(data=config, target=config_path, should_preserve_key_order=True)
+
+
+def _is_custom_prompt(
+    studio_prompt: Optional[Text], system_prompt: Optional[Text]
+) -> bool:
+    """Check if the prompt has been customized in Studio.
+
+    Args:
+        studio_prompt: The prompt content from the Studio.
+        system_prompt: The default system prompt content.
+    """
+    return bool(studio_prompt and studio_prompt != system_prompt)
+
+
+def _save_prompt_file(root: Path, filename: str, content: str) -> Path:
+    """Save a prompt file to the specified root directory.
+
+    Args:
+        root: The root directory where the prompt file will be saved.
+        filename: The name of the prompt file.
+        content: The content of the prompt.
+    """
+    prompts_dir = root / DEFAULT_PROMPTS_PATH
+    prompts_dir.mkdir(parents=True, exist_ok=True)
+
+    file_path = prompts_dir / filename
+    file_path.write_text(content, encoding="utf-8")
+
+    return file_path.relative_to(root)
+
+
+def _add_prompt_to_config(
+    *,
+    config: Dict,
+    section_key: str,
+    component_names: List[str],
+    prompt_key: str,
+    prompt_path: str,
+) -> None:
+    """Add a prompt path to the specified section of the configuration."""
+    matches = [
+        component
+        for component in config.get(section_key, [])
+        if component.get(CONFIG_NAME_KEY) in component_names
+    ]
+
+    if not matches:
+        return
+
+    # Update the first occurrence of the component.
+    matches[0][prompt_key] = prompt_path
+
+    if len(matches) > 1:
+        structlogger.warning(
+            "rasa.studio.prompts.add_prompt_to_config.multiple_components",
+            event_info=(
+                "Multiple components found in the configuration for the same prompt."
+            ),
+        )

rasa/studio/{download/flows.py → pull/data.py}

@@ -3,106 +3,16 @@ from pathlib import Path
 from typing import Any, Dict, List, Set, Text
 
 from rasa.shared.core.flows import Flow
-from rasa.shared.core.flows.flow_step_links import StaticFlowStepLink
 from rasa.shared.core.flows.flows_list import FlowsList
 from rasa.shared.core.flows.yaml_flows_io import YAMLFlowsReader, YamlFlowsWriter
 from rasa.shared.importers.importer import TrainingDataImporter
 from rasa.shared.utils.yaml import read_yaml
 from rasa.studio.constants import STUDIO_NLU_FILENAME
-from rasa.studio.data_handler import StudioDataHandler
 from rasa.utils.mapper import RasaPrimitiveStorageMapper
 
 logger = logging.getLogger(__name__)
 
-STUDIO_FLOWS_DIR_NAME = "studio_flows"
-
-
-def merge_flows_with_overwrite(
-    data_paths: List[Path],
-    handler: Any,
-    data_from_studio: TrainingDataImporter,
-    data_local: TrainingDataImporter,
-    mapper: RasaPrimitiveStorageMapper,
-) -> None:
-    """
-    Merges flows data from a file or directory when overwrite is enabled.
-
-    Args:
-        data_paths: List of paths to the training data.
-        handler: The StudioDataHandler instance.
-        data_from_studio: The TrainingDataImporter instance for Studio data.
-        data_local: The TrainingDataImporter instance for local data.
-        mapper: The RasaPrimitiveStorageMapper instance for mapping.
-    """
-    if len(data_paths) != 1:
-        # TODO: Handle multiple data paths.
-        raise NotImplementedError("Multiple data paths are not supported yet.")
-
-    data_path = data_paths[0]
-    if data_path.is_file():
-        merge_training_data_file(handler, data_from_studio, data_local, data_path)
-    elif data_path.is_dir():
-        merge_training_data_dir(
-            handler, data_from_studio, data_local, data_path, mapper
-        )
-    else:
-        raise ValueError("Provided data path is neither a file nor a directory.")
-
-
-def merge_training_data_file(
-    handler: StudioDataHandler,
-    data_from_studio: TrainingDataImporter,
-    data_local: TrainingDataImporter,
-    file_path: Path,
-) -> None:
-    """
-    Merges NLU and flows data when training data is stored in a single file.
-
-    Args:
-        handler: The StudioDataHandler instance.
-        data_from_studio: The TrainingDataImporter instance for Studio data.
-        data_local: The TrainingDataImporter instance for local data.
-        file_path: The path to the training data file.
-    """
-    if handler.has_nlu():
-        nlu_data_merged = data_from_studio.get_nlu_data().merge(
-            data_local.get_nlu_data()
-        )
-        nlu_data_merged.persist_nlu(file_path)
-
-    if handler.has_flows():
-        flows_data_merged = data_from_studio.get_user_flows().merge(
-            data_local.get_user_flows()
-        )
-        YamlFlowsWriter.dump(
-            flows=flows_data_merged.underlying_flows,
-            filename=file_path,
-            should_clean_json=True,
-        )
-
-
-def merge_training_data_dir(
-    handler: StudioDataHandler,
-    data_from_studio: TrainingDataImporter,
-    data_local: TrainingDataImporter,
-    data_path: Path,
-    mapper: RasaPrimitiveStorageMapper,
-) -> None:
-    """
-    Merges NLU and flows data when training data is stored in a directory.
-
-    Args:
-        handler: The StudioDataHandler instance.
-        data_from_studio: The TrainingDataImporter instance for Studio data.
-        data_local: The TrainingDataImporter instance for local data.
-        data_path: The path to the training data directory.
-        mapper: The RasaPrimitiveStorageMapper instance for mapping.
-    """
-    if handler.has_nlu():
-        merge_nlu_in_directory(data_from_studio, data_local, data_path, mapper)
-
-    if handler.has_flows():
-        merge_flows_in_directory(data_from_studio, data_path, mapper)
+STUDIO_FLOWS_DIR_NAME = "flows"
 
 
 def merge_nlu_in_directory(
@@ -121,7 +31,7 @@ def merge_nlu_in_directory(
         data_path: The path to the training data directory.
         mapper: The RasaPrimitiveStorageMapper instance for mapping.
     """
-    from rasa.studio.download.download import pretty_write_nlu_yaml
+    from rasa.studio.download import pretty_write_nlu_yaml
 
     nlu_data = data_from_studio.get_nlu_data()
     nlu_file_path = get_nlu_path(data_path, data_local, mapper)
@@ -132,7 +42,8 @@ def merge_nlu_in_directory(
         )
         nlu_data = nlu_data.merge(local_nlu.get_nlu_data())
 
-    pretty_write_nlu_yaml(read_yaml(nlu_data.nlu_as_yaml()), nlu_file_path)
+    if nlu_yaml := nlu_data.nlu_as_yaml():
+        pretty_write_nlu_yaml(read_yaml(nlu_yaml), nlu_file_path)
 
 
 def get_nlu_path(
@@ -158,29 +69,6 @@ def get_nlu_path(
     return _select_path(nlu_paths, "nlu", base_path, STUDIO_NLU_FILENAME)
 
 
-def get_flows_path(
-    base_path: Path,
-    data_local: TrainingDataImporter,
-    mapper: RasaPrimitiveStorageMapper,
-) -> Path:
-    """Determines where flows data should be stored.
-
-    Args:
-        base_path: The base path for the training data.
-        data_local: The TrainingDataImporter instance for local data.
-        mapper: The RasaPrimitiveStorageMapper instance for mapping.
-
-    Returns:
-        The path where flows data should be stored.
-    """
-    flow_paths = set()
-    for flow in data_local.get_user_flows().underlying_flows:
-        for p in mapper.get_file(flow.id, "flows").get("training", []):
-            flow_paths.add(p)
-
-    return _select_path(flow_paths, "flows", base_path, "flows.yml")
-
-
 def merge_flows_in_directory(
     data_from_studio: TrainingDataImporter,
     data_path: Path,
@@ -211,14 +99,16 @@ def merge_flows_in_directory(
     local_flow_paths: Set[Path] = _get_local_flow_paths(local_flows, mapper)
 
     # Track updated flows and update local files with Studio flow data.
-    all_updated_flows: List[Flow] = []
+    all_updated_flows_ids: List[Text] = []
     for flow_file_path in local_flow_paths:
-        updated_file_flows = _update_flow_file(flow_file_path, studio_flow_map)
-        all_updated_flows.extend(updated_file_flows)
+        updated_flows_ids = _update_flow_file(flow_file_path, studio_flow_map)
+        all_updated_flows_ids.extend(updated_flows_ids)
 
     # Identify new Studio flows and save them as separate files in the directory.
     new_flows = [
-        flow for flow in studio_flow_map.values() if flow not in all_updated_flows
+        flow
+        for flow_id, flow in studio_flow_map.items()
+        if flow_id not in all_updated_flows_ids
     ]
     _dump_flows_as_separate_files(new_flows, data_path)
 
@@ -243,7 +133,7 @@ def _get_local_flow_paths(
 
 def _update_flow_file(
     flow_file_path: Path, studio_flows_map: Dict[Text, Any]
-) -> List[Flow]:
+) -> List[Text]:
     """
     Reads a flow file, updates outdated flows, and replaces them with studio versions.
 
@@ -252,31 +142,25 @@ def _update_flow_file(
         studio_flows_map: A dictionary mapping flow IDs to their updated versions.
 
     Returns:
-        A list of flows from the updated flow file.
+        A list of Flows IDs from the updated flow file.
     """
     file_flows = YAMLFlowsReader.read_from_file(flow_file_path, False)
-    updated_list: List[Any] = []
-    has_changes = False
-
-    for flow in file_flows.underlying_flows:
-        studio_flow = studio_flows_map.get(flow.id)
-        if studio_flow is not None and studio_flow != flow:
-            updated_list.append(studio_flow)
-            has_changes = True
-        else:
-            updated_list.append(flow)
-
-    if has_changes:
-        new_flows_list = FlowsList(underlying_flows=updated_list)
-        new_flows_list = strip_default_next_references(new_flows_list)
+
+    # Build a list of flows, replacing any outdated flow with its studio version
+    updated_flows = [
+        studio_flows_map.get(flow.id, flow) or flow
+        for flow in file_flows.underlying_flows
+    ]
+
+    # If the updated flows differ from the original file flows, write them back
+    if updated_flows != file_flows.underlying_flows:
         YamlFlowsWriter.dump(
-            flows=new_flows_list.underlying_flows,
+            flows=updated_flows,
             filename=flow_file_path,
             should_clean_json=True,
         )
-        return new_flows_list.underlying_flows
 
-    return file_flows.underlying_flows
+    return [flow.id for flow in updated_flows]
 
 
 def _dump_flows_as_separate_files(flows: List[Any], data_path: Path) -> None:
@@ -306,27 +190,6 @@ def _dump_flows_as_separate_files(flows: List[Any], data_path: Path) -> None:
         )
 
 
-def strip_default_next_references(flows: FlowsList) -> FlowsList:
-    """Strips default next references from flows.
-
-    Args:
-        flows: The FlowsList instance containing the flows.
-
-    Returns:
-        An updated FlowsList instance with default next references removed.
-    """
-    default_step_ids = [step.default_id for flow in flows for step in flow.steps]
-    for flow in flows:
-        for step in flow.steps:
-            if (
-                step.next.links
-                and isinstance(step.next.links[0], StaticFlowStepLink)
-                and step.next.links[0].target in default_step_ids
-            ):
-                step.next.links = []
-    return flows
-
-
 def _select_path(
     paths: Set[Path], primitive_type: str, default_path: Path, default: str
 ) -> Path:

rasa/studio/{download → pull}/domains.py

@@ -10,7 +10,7 @@ from rasa.studio.constants import STUDIO_DOMAIN_FILENAME
 logger = logging.getLogger(__name__)
 
 
-def merge_domain_with_overwrite(
+def merge_domain(
     data_from_studio: TrainingDataImporter,
     data_local: TrainingDataImporter,
     domain_path: Path,