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

rasa/llm_fine_tuning/paraphrasing/conversation_rephraser.py

@@ -35,7 +35,7 @@ DEFAULT_REPHRASING_PROMPT_TEMPLATE = importlib.resources.read_text(
 
 DEFAULT_LLM_CONFIG = {
     PROVIDER_CONFIG_KEY: OPENAI_PROVIDER,
-    MODEL_CONFIG_KEY: "gpt-4o-mini",
+    MODEL_CONFIG_KEY: "gpt-4.1-mini-2025-04-14",
     TIMEOUT_CONFIG_KEY: 7,
     TEMPERATURE_CONFIG_KEY: 0.0,
     MAX_COMPLETION_TOKENS_CONFIG_KEY: 4096,

rasa/model_manager/runner_service.py

@@ -2,7 +2,8 @@ import os
 import shutil
 import subprocess
 from enum import Enum
-from typing import Dict, Optional
+from pathlib import Path
+from typing import Dict, Optional, Union
 
 import aiohttp
 import structlog
@@ -18,6 +19,7 @@ from rasa.model_manager.utils import (
     write_encoded_data_to_file,
 )
 from rasa.model_manager.warm_rasa_process import start_rasa_process
+from rasa.studio.prompts import handle_prompts
 
 structlogger = structlog.get_logger()
 
@@ -121,11 +123,25 @@ def get_open_port() -> int:
 
 
 def write_encoded_config_data_to_files(
-    encoded_configs: Dict[str, bytes], base_path: str
+    encoded_configs: Dict[str, Union[bytes, Dict[str, str]]], base_path: str
 ) -> None:
     """Write the encoded config data to files."""
-    for key, value in encoded_configs.items():
-        write_encoded_data_to_file(value, subpath(base_path, f"{key}.yml"))
+    endpoints_encoded = encoded_configs.get("endpoints")
+    if endpoints_encoded:
+        write_encoded_data_to_file(
+            endpoints_encoded, subpath(base_path, "endpoints.yml")
+        )
+    config_encoded = encoded_configs.get("config")
+    if config_encoded:
+        write_encoded_data_to_file(config_encoded, subpath(base_path, "config.yml"))
+    credentials_encoded = encoded_configs.get("credentials")
+    if credentials_encoded:
+        write_encoded_data_to_file(
+            credentials_encoded, subpath(base_path, "credentials.yml")
+        )
+
+    if prompts := encoded_configs.get("prompts"):
+        handle_prompts(prompts, Path(base_path))
 
 
 def prepare_bot_directory(

rasa/model_manager/trainer_service.py

@@ -2,6 +2,7 @@ import os
 import shutil
 import subprocess
 from enum import Enum
+from pathlib import Path
 from typing import Any, Dict, Optional
 
 import structlog
@@ -20,6 +21,7 @@ from rasa.model_manager.warm_rasa_process import (
     start_rasa_process,
 )
 from rasa.model_training import generate_random_model_name
+from rasa.studio.prompts import handle_prompts
 
 structlogger = structlog.get_logger()
 
@@ -208,6 +210,7 @@ def write_training_data_to_files(
         "stories": "base64 encoded stories.yml",
         "rules": "base64 encoded rules.yml",
         "nlu": "base64 encoded nlu.yml"
+        "prompts": "dictionary with the prompts",
     }
     ```
     """
@@ -230,6 +233,9 @@ def write_training_data_to_files(
             subpath(training_base_path + "/" + parent_path, file_name),
         )
 
+    if prompts := encoded_training_data.get("prompts"):
+        handle_prompts(prompts, Path(training_base_path))
+
 
 def prepare_training_directory(
     training_base_path: str, assistant_id: str, encoded_training_data: Dict[str, Any]

rasa/privacy/privacy_filter.py

@@ -2,6 +2,7 @@ import copy
 import datetime
 import json
 import os
+from pathlib import Path
 from typing import Any, Dict, List, Optional
 
 import structlog
@@ -60,8 +61,17 @@ class PrivacyFilter:
     def _load_gliner_model() -> Optional[Any]:
         """Load the GLiNER model for PII detection."""
         local_model_path = os.getenv(GLINER_MODEL_PATH_ENV_VAR_NAME)
-        cache_dir = os.getenv(HUGGINGFACE_CACHE_DIR_ENV_VAR_NAME)
-        model_path = local_model_path or DEFAULT_PII_MODEL
+        cache_dir_env_value = os.getenv(HUGGINGFACE_CACHE_DIR_ENV_VAR_NAME)
+        cache_dir = Path(cache_dir_env_value).resolve() if cache_dir_env_value else None
+        model_path = (
+            Path(local_model_path).resolve() if local_model_path else DEFAULT_PII_MODEL
+        )
+        local_files_only = isinstance(model_path, Path) and model_path.exists()
+
+        structlogger.debug(
+            "rasa.privacy.privacy_filter.loading_gliner_model",
+            local_files_only=local_files_only,
+        )
 
         try:
             from gliner import GLiNER
@@ -69,6 +79,7 @@ class PrivacyFilter:
             return GLiNER.from_pretrained(
                 model_path,
                 cache_dir=cache_dir,
+                local_files_only=local_files_only,
             )
         except ImportError:
             structlogger.warning(
@@ -193,7 +204,9 @@ class PrivacyFilter:
 
         for key, slot in anonymized_slots.items():
             original_slot_value = key.split(":", 1)[1]
-            anonymized_text = user_event.text.replace(original_slot_value, slot.value)
+            anonymized_text = self._smart_replace(
+                user_event.text, original_slot_value, slot.value
+            )
             user_event.text = anonymized_text
 
             anonymized_parse_data[TEXT_KEY] = anonymized_text
@@ -232,7 +245,9 @@ class PrivacyFilter:
 
         for key, slot in anonymized_slots.items():
             original_slot_value = key.split(":", 1)[1]
-            anonymized_text = bot_event.text.replace(original_slot_value, slot.value)
+            anonymized_text = self._smart_replace(
+                bot_event.text, original_slot_value, slot.value
+            )
             bot_event.text = anonymized_text
 
         bot_event.text = self._anonymize_edge_cases(bot_event.text, anonymized_slots)
@@ -338,3 +353,41 @@ class PrivacyFilter:
             text = text.replace(entity_value, self._mask(entity[ENTITY_LABEL_KEY]))
 
         return text
+
+    @staticmethod
+    def _smart_replace(text: str, original_value: str, replacement: str) -> str:
+        """Replace original_value with replacement in text.
+
+        This method performs a string replacement in the text,
+        with special handling for floats.
+        If original_value is a float string like "24.0",
+        also tries replacing the integer version "24".
+
+        Args:
+            text (str): The text to perform replacements on
+            original_value (str): The value to replace
+            replacement (str): The replacement value
+
+        Returns:
+            str: The text with replacements applied
+        """
+        # First try the original replacement
+        result = text.replace(original_value, replacement)
+        if text != result:
+            return result
+
+        # If replacement didn't happen and it's a float,
+        # try replacing the integer version
+        if "." in original_value:
+            try:
+                float_val = float(original_value)
+                if float_val.is_integer():
+                    int_version = str(int(float_val))
+                    result = result.replace(int_version, replacement)
+            except ValueError:
+                structlogger.warning(
+                    "rasa.privacy.privacy_filter.smart_replace_float_error",
+                    event_info="Unable to anonymize float value.",
+                )
+
+        return result

rasa/privacy/privacy_manager.py

@@ -12,7 +12,7 @@ import structlog
 from apscheduler.schedulers.background import BackgroundScheduler
 
 import rasa.shared.core.trackers
-from rasa.core.tracker_stores.tracker_store import TrackerStore
+from rasa.core.tracker_stores.tracker_store import FailSafeTrackerStore, TrackerStore
 from rasa.privacy.constants import (
     TEXT_KEY,
     USER_CHAT_INACTIVITY_IN_MINUTES_ENV_VAR_NAME,
@@ -63,6 +63,7 @@ class BackgroundPrivacyManager:
         self,
         endpoints: Optional["AvailableEndpoints"],
         event_loop: Optional["AbstractEventLoop"] = None,
+        in_memory_tracker_store: Optional[TrackerStore] = None,
     ):
         self.config = (
             PrivacyConfig.from_dict(endpoints.privacy)
@@ -76,15 +77,28 @@ class BackgroundPrivacyManager:
             os.getenv(USER_CHAT_INACTIVITY_IN_MINUTES_ENV_VAR_NAME, 30)
         )
 
-        # we recreate the tracker store here to ensure
-        # that this instance has no event brokers
-        # that could publish events during the tracker store
-        # background jobs
-        self.tracker_store = (
-            TrackerStore.create(endpoints.tracker_store)
-            if endpoints
-            else TrackerStore.create(None)
-        )
+        if in_memory_tracker_store is not None:
+            # if an in-memory tracker store is provided,
+            # we need to keep the reference to it
+            # so that the background jobs can access it.
+            # We also set the event broker to None
+            # to prevent it from publishing events
+            # during the tracker store background jobs
+            in_memory_tracker_store.event_broker = None
+            tracker_store = in_memory_tracker_store
+        else:
+            # we recreate the tracker store here to ensure
+            # that this instance has no event brokers
+            # that could publish events during the tracker store
+            # background jobs
+            tracker_store = (
+                TrackerStore.create(endpoints.tracker_store)
+                if endpoints
+                else TrackerStore.create(None)
+            )
+
+        self.tracker_store = FailSafeTrackerStore(tracker_store)
+
         self.event_brokers: List["EventBroker"] = []
         self.event_loop = event_loop
 
@@ -124,9 +138,10 @@ class BackgroundPrivacyManager:
         cls,
         endpoints: Optional["AvailableEndpoints"],
         event_loop: Optional["AbstractEventLoop"] = None,
+        in_memory_tracker_store: Optional[TrackerStore] = None,
     ) -> BackgroundPrivacyManager:
         """Create an instance of BackgroundPrivacyManager."""
-        instance = cls(endpoints, event_loop)
+        instance = cls(endpoints, event_loop, in_memory_tracker_store)
         return await instance.initialize(endpoints)
 
     def stop(self) -> None:
@@ -337,7 +352,7 @@ class BackgroundPrivacyManager:
             if not full_tracker:
                 structlogger.debug(
                     "rasa.privacy_manager.no_tracker_found_for_sender_id",
-                    key=key,
+                    sender_id=key,
                 )
                 continue
 
@@ -359,7 +374,7 @@ class BackgroundPrivacyManager:
 
             structlogger.info(
                 "rasa.privacy_manager.save_tracker_after_deletion",
-                key=key,
+                sender_id=key,
                 event_info="Saved tracker with events not scheduled "
                 "for deletion yet.",
             )
@@ -508,7 +523,7 @@ class BackgroundPrivacyManager:
             ):
                 structlogger.info(
                     "rasa.privacy_manager.anonymizing_tracker_session",
-                    key=session.sender_id,
+                    sender_id=session.sender_id,
                     last_event_timestamp=last_event_timestamp,
                     triggered_by="anonymization_cron_job",
                 )
@@ -524,7 +539,7 @@ class BackgroundPrivacyManager:
                 uneligible_events.extend(events)
                 structlogger.debug(
                     "rasa.privacy_manager.session_not_valid_for_anonymization",
-                    key=session.sender_id,
+                    sender_id=session.sender_id,
                     session_id=session.sender_id,
                     last_event_timestamp=last_event_timestamp,
                 )
@@ -560,7 +575,7 @@ class BackgroundPrivacyManager:
 
                 structlogger.info(
                     "rasa.privacy_manager.tracker_session_scheduled_for_deletion",
-                    key=full_tracker.sender_id,
+                    sender_id=full_tracker.sender_id,
                     last_event_timestamp=last_event_timestamp,
                     triggered_by="deletion_cron_job",
                 )

rasa/shared/constants.py

@@ -104,6 +104,8 @@ UTTER_FREE_CHITCHAT_RESPONSE = "utter_free_chitchat_response"
 ASSISTANT_ID_KEY = "assistant_id"
 ASSISTANT_ID_DEFAULT_VALUE = "placeholder_default"
 
+ENDPOINTS_NLG_KEY = "nlg"
+
 CONFIG_MANDATORY_COMMON_KEYS = [ASSISTANT_ID_KEY]
 CONFIG_NAME_KEY = "name"
 CONFIG_POLICIES_KEY = "policies"

rasa/shared/core/constants.py

@@ -182,6 +182,7 @@ class SetSlotExtractor(Enum):
 # the keys for `State` (USER, PREVIOUS_ACTION, SLOTS, ACTIVE_LOOP)
 # represent the origin of a `SubState`
 USER = "user"
+BOT = "bot"
 SLOTS = "slots"
 
 USE_TEXT_FOR_FEATURIZATION = "use_text_for_featurization"

rasa/shared/utils/llm.py

@@ -6,6 +6,7 @@ import logging
 from copy import deepcopy
 from datetime import datetime
 from functools import wraps
+from pathlib import Path
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -24,6 +25,9 @@ from typing import (
 import structlog
 from pydantic import BaseModel, Field
 
+import rasa.cli.telemetry
+import rasa.cli.utils
+import rasa.shared.utils.cli
 import rasa.shared.utils.io
 from rasa.core.available_endpoints import AvailableEndpoints
 from rasa.shared.constants import (
@@ -31,6 +35,7 @@ from rasa.shared.constants import (
     CONFIG_PIPELINE_KEY,
     CONFIG_POLICIES_KEY,
     DEFAULT_PROMPT_PACKAGE_NAME,
+    ENDPOINTS_NLG_KEY,
     LLM_CONFIG_KEY,
     MODEL_CONFIG_KEY,
     MODEL_GROUP_CONFIG_KEY,
@@ -578,7 +583,7 @@ def embedder_factory(
     ```
     {
        "provider": "openai",
-       "model": "text-embedding-3-small",
+       "model": "text-embedding-3-large",
        "timeout": 10,
        "num_retries": 3,
     }
@@ -591,7 +596,7 @@ def embedder_factory(
         "models": [
             {
                 "provider": "openai",
-                "model": "test-embedding-3-small",
+                "model": "test-embedding-3-large",
                 "api_key": "test"
             },
         ],
@@ -1072,3 +1077,82 @@ def get_system_default_prompts(
         enterprise_search=_get_enterprise_search_prompt(config),
         contextual_response_rephraser=DEFAULT_RESPONSE_VARIATION_PROMPT_TEMPLATE,
     )
+
+
+def collect_custom_prompts(
+    config: Dict[Text, Any],
+    endpoints: Dict[Text, Any],
+    project_root: Optional[Path] = None,
+) -> Dict[Text, Text]:
+    """Collects custom prompts from the project configuration and endpoints.
+
+    Args:
+        config: The configuration dictionary of the project.
+        endpoints: The endpoints configuration dictionary.
+        project_root: The root directory of the project.
+
+    Returns:
+        A dictionary containing custom prompts.
+        The keys are:
+            - 'contextual_response_rephraser'
+            - 'command_generator'
+            - 'enterprise_search'
+    """
+    from rasa.core.policies.enterprise_search_policy import EnterpriseSearchPolicy
+    from rasa.dialogue_understanding.generator.llm_based_command_generator import (
+        LLMBasedCommandGenerator,
+    )
+    from rasa.studio.prompts import (
+        COMMAND_GENERATOR_NAME,
+        CONTEXTUAL_RESPONSE_REPHRASER_NAME,
+        ENTERPRISE_SEARCH_NAME,
+    )
+
+    prompts: Dict[Text, Text] = {}
+    project_root = project_root or Path(".").resolve()
+
+    def _read_prompt(root: Path, path_in_yaml: Text) -> Optional[Text]:
+        if not path_in_yaml:
+            return None
+
+        prompt_path = (
+            (root / path_in_yaml).resolve()
+            if not Path(path_in_yaml).is_absolute()
+            else Path(path_in_yaml)
+        )
+        if prompt_path.exists():
+            return prompt_path.read_text(encoding="utf-8")
+
+        structlogger.warning(
+            "utils.llm.collect_custom_prompts.prompt_not_found",
+            event_info=(f"Prompt file '{prompt_path}' not found. "),
+            prompt_path=prompt_path,
+            project_root=root,
+        )
+        return None
+
+    # contextual_response_rephraser
+    nlg_conf = endpoints.get(ENDPOINTS_NLG_KEY) or {}
+    if prompt_text := _read_prompt(project_root, nlg_conf.get(PROMPT_CONFIG_KEY)):
+        prompts[CONTEXTUAL_RESPONSE_REPHRASER_NAME] = prompt_text
+
+    # command_generator
+    command_generator_classes = {
+        cls.__name__ for cls in all_subclasses(LLMBasedCommandGenerator)
+    }
+    for component in config.get(CONFIG_PIPELINE_KEY, []):
+        if component.get(CONFIG_NAME_KEY) in command_generator_classes:
+            if prompt_text := _read_prompt(
+                project_root, component.get(PROMPT_TEMPLATE_CONFIG_KEY)
+            ):
+                prompts[COMMAND_GENERATOR_NAME] = prompt_text
+                break
+
+    # enterprise_search
+    for policy in config.get(CONFIG_POLICIES_KEY, []):
+        if policy.get(CONFIG_NAME_KEY) == EnterpriseSearchPolicy.__name__:
+            if prompt_text := _read_prompt(project_root, policy.get(PROMPT_CONFIG_KEY)):
+                prompts[ENTERPRISE_SEARCH_NAME] = prompt_text
+            break
+
+    return prompts

rasa/studio/data_handler.py

@@ -1,5 +1,4 @@
 import base64
-import json
 import logging
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple
@@ -46,15 +45,33 @@ class StudioDataHandler:
         intent_names: Optional[List[str]] = None,
         entity_names: Optional[List[str]] = None,
     ) -> dict:
+        from rasa.studio.prompts import (
+            COMMAND_GENERATOR_NAME,
+            CONTEXTUAL_RESPONSE_REPHRASER_NAME,
+            ENTERPRISE_SEARCH_NAME,
+        )
+
         request = {
-            "query": (
-                "query ExportAsEncodedYaml($input: ExportAsEncodedYamlInput!) "
-                "{ exportAsEncodedYaml(input: $input) "
-                "{ ... on ExportModernAsEncodedYamlOutput "
-                "{ nlu flows domain endpoints config prompts } "
-                "... on ExportClassicAsEncodedYamlOutput "
-                "{ nlu domain }}}"
-            ),
+            "query": "query ExportAsEncodedYaml($input: ExportAsEncodedYamlInput!) {\n"
+            "  exportAsEncodedYaml(input: $input) {\n"
+            "    ... on ExportModernAsEncodedYamlOutput {\n"
+            "      nlu\n"
+            "      flows\n"
+            "      domain\n"
+            "      endpoints\n"
+            "      config\n"
+            "      prompts {\n"
+            f"        {COMMAND_GENERATOR_NAME}\n"
+            f"        {CONTEXTUAL_RESPONSE_REPHRASER_NAME}\n"
+            f"        {ENTERPRISE_SEARCH_NAME}\n"
+            "      }\n"
+            "    }\n"
+            "    ... on ExportClassicAsEncodedYamlOutput {\n"
+            "      nlu\n"
+            "      domain\n"
+            "    }\n"
+            "  }\n"
+            "}\n",
             "variables": {"input": {"assistantName": self.assistant_name}},
         }
         if intent_names or entity_names:
@@ -98,7 +115,6 @@ class StudioDataHandler:
             },
             verify=verify,
         )
-
         if res.status_code != 200:
             raise RasaException(
                 f"Download from Studio with URL: "
@@ -203,9 +219,7 @@ class StudioDataHandler:
         self.flows = self._decode_response(return_data.get("flows"))
         self.config = self._decode_response(return_data.get("config"))
         self.endpoints = self._decode_response(return_data.get("endpoints"))
-
-        prompts_string = self._decode_response(return_data.get("prompts"))
-        self.prompts = json.loads(prompts_string) if prompts_string else None
+        self.prompts = return_data.get("prompts")
 
         if not self.has_nlu() and not self.has_flows():
             raise RasaException("No nlu or flows data in Studio response.")

rasa/studio/download.py

@@ -25,6 +25,7 @@ from rasa.studio.constants import DOMAIN_FILENAME
 from rasa.studio.data_handler import StudioDataHandler
 from rasa.studio.prompts import handle_prompts
 from rasa.studio.pull.data import _dump_flows_as_separate_files
+from rasa.studio.utils import validate_argument_paths
 
 structlogger = structlog.get_logger()
 
@@ -35,6 +36,7 @@ def handle_download(args: argparse.Namespace) -> None:
     Args:
         args: The command line arguments.
     """
+    validate_argument_paths(args)
     assistant_name = args.assistant_name
     target_root = _prepare_target_directory(assistant_name)
 
@@ -47,7 +49,9 @@ def handle_download(args: argparse.Namespace) -> None:
     _handle_endpoints(handler, target_root)
     _handle_domain(handler, target_root)
     _handle_data(handler, target_root)
-    handle_prompts(handler, target_root)
+
+    if prompts := handler.get_prompts():
+        handle_prompts(prompts, target_root)
 
     structlogger.info(
         "studio.download.success",

rasa/studio/link.py

@@ -179,8 +179,19 @@ def handle_link(args: argparse.Namespace) -> None:
     link_file = _link_file(project_root)
 
     if link_file.exists():
+        linked_assistant_name = read_assistant_name(project_root)
+        if linked_assistant_name == assistant_name:
+            rasa.shared.utils.cli.print_info(
+                f"Project is already linked to assistant '{assistant_name}'."
+            )
+            sys.exit(0)
+
         overwrite = questionary.confirm(
-            f"This project is already linked " f"(link file '{link_file}').\nOverwrite?"
+            f"Project is currently linked to the following Rasa Studio assistant:\n\n"
+            f"  Assistant name: {linked_assistant_name}\n"
+            f"  Studio URL: {studio_cfg.studio_url}\n"
+            f"  Keycloak Auth URL: {studio_cfg.authentication_server_url}\n\n"
+            f"Do you want to overwrite it with the new assistant '{assistant_name}'?"
         ).ask()
         if not overwrite:
             rasa.shared.utils.cli.print_info(

rasa/studio/prompts.py

@@ -20,7 +20,6 @@ from rasa.shared.constants import (
 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()
 
@@ -29,14 +28,13 @@ COMMAND_GENERATOR_NAME = "command_generator"
 ENTERPRISE_SEARCH_NAME = "enterprise_search"
 
 
-def handle_prompts(handler: StudioDataHandler, root: Path) -> None:
+def handle_prompts(prompts: Dict[Text, Text], root: Path) -> None:
     """Handle prompts for the assistant.
 
     Args:
-        handler: The data handler to retrieve prompts from.
+        prompts: A dict containing prompt names as keys and their content as values.
         root: The root directory where the prompts should be saved.
     """
-    prompts = handler.get_prompts()
     if not prompts:
         return
 
@@ -85,7 +83,7 @@ def _handle_contextual_response_rephraser(
         return
 
     prompt_path = _save_prompt_file(
-        root, f"{CONTEXTUAL_RESPONSE_REPHRASER_NAME}.jinja", prompt_content
+        root, f"{CONTEXTUAL_RESPONSE_REPHRASER_NAME}.jinja2", prompt_content
     )
 
     endpoints["nlg"] = endpoints.get("nlg") or {}
@@ -113,7 +111,7 @@ def _handle_command_generator(
         return
 
     prompt_path = _save_prompt_file(
-        root, f"{COMMAND_GENERATOR_NAME}.jinja", prompt_content
+        root, f"{COMMAND_GENERATOR_NAME}.jinja2", prompt_content
     )
 
     command_generator_names: List[str] = [
@@ -149,7 +147,7 @@ def _handle_enterprise_search(
         return
 
     prompt_path = _save_prompt_file(
-        root, f"{ENTERPRISE_SEARCH_NAME}.jinja", prompt_content
+        root, f"{ENTERPRISE_SEARCH_NAME}.jinja2", prompt_content
     )
 
     _add_prompt_to_config(

rasa/studio/pull/domains.py

@@ -15,8 +15,7 @@ def merge_domain(
     data_local: TrainingDataImporter,
     domain_path: Path,
 ) -> None:
-    """
-    Merges the domain from Rasa Studio with the local domain.
+    """Merges the domain from Rasa Studio with the local domain.
 
     Args:
         data_from_studio: The training data importer for the Rasa Studio domain.
@@ -29,10 +28,22 @@ def merge_domain(
     else:
         all_local_domain_files = data_local.get_domain_files([str(domain_path)])
 
+    studio_domain_file_path = domain_path / STUDIO_DOMAIN_FILENAME
+
     # leftover_domain represents the items in the studio
     # domain that are not in the local domain
     leftover_domain = data_from_studio.get_user_domain()
     for file_path in all_local_domain_files:
+        if file_path == str(studio_domain_file_path):
+            # we need to exclude the studio domain file from the merge,
+            # since we want to dump ALL the remaining items to this path
+            # after the merge. if we include it here, we will remove the existing
+            # items from the leftover domain and after this loop we will
+            # overwrite the studio domain file with the remaining items in
+            # the leftover domain - this means we loose the items that were
+            # in the studio domain file before we started the merge.
+            continue
+
         # For each local domain file, we do a partial merge
         local_domain = Domain.from_file(str(file_path))
         updated_local_domain = local_domain.partial_merge(leftover_domain)
@@ -46,4 +57,4 @@ def merge_domain(
 
     # If there are still items in leftover_domain, persist them
     if not leftover_domain.is_empty():
-        leftover_domain.persist(domain_path / STUDIO_DOMAIN_FILENAME)
+        leftover_domain.persist(studio_domain_file_path)