rasa-pro 3.10.7.dev5__py3-none-any.whl → 3.10.9__py3-none-any.whl

README.md

@@ -236,6 +236,39 @@ To check the types execute
 make types
 ```
 
+### Backporting
+
+In order to port changes to `main` and across release branches, we use the `backport` workflow located at
+the `.github/workflows/backport.yml` path.
+This workflow is triggered by the `backport-to-<release-branch>` label applied to a PR, for example `backport-to-3.8.x`.
+Current available target branches are `main` and maintained release branches.
+
+When a PR gets labelled `backport-to-<release-branch>`, a PR is opened by the `backport-github-action` as soon as the
+source PR gets closed (by merging). If you want to close the PR without merging changes, make sure to remove the `backport-to-<release-branch>` label.
+
+The PR author which the action assigns to the backporting PR has to resolve any conflicts before approving and merging.
+Release PRs should also be labelled with `backport-to-main` to backport the `CHANGELOG.md` updates to `main`.
+Backporting version updates should be accepted to the `main` branch from the latest release branch only.
+
+Here are some guidelines to follow when backporting changes and resolving conflicts:
+
+a) for conflicts in `version.py`: accept only the version from the latest release branch. Do not merge version changes
+from earlier release branches into `main` because this could cause issues when trying to make the next minor release.
+
+b) for conflicts in `pyproject.toml`: if related to the `rasa-pro` version, accept only the latest release branch; 
+if related to other dependencies, accept `main` or whichever is the higher upgrade (main usually has the updated 
+dependencies because we only do housekeeping on `main`, apart from vulnerability updates). Be mindful of dependencies that
+are removed from `main` but still exist in former release branches (for example `langchain`).
+
+c) for conflicts in `poetry.lock`: accept changes which were already present on the target branch, then run
+`poetry lock --no-update` so that the lock file contains your changes from `pyproject.toml` too.
+
+d) for conflicts in `CHANGELOG.md`: Manually place the changelog in their allocated section (e.g. 3.8.10 will go under the 
+3.8 section with the other releases, rather than go at the top of the file)
+
+If the backporting workflow fails, you are encouraged to cherry-pick the commits manually and create a PR to
+the target branch. Alternatively, you can install the backporting CLI tool as described [here](https://github.com/sorenlouv/backport?tab=readme-ov-file#install).
+
 ## Releases
 Rasa has implemented robust policies governing version naming, as well as release pace for major, minor, and patch releases.
 
@@ -318,9 +351,12 @@ Releasing a new version is quite simple, as the packages are build and distribut
 9. If however an error occurs in the build, then we should see a failure message automatically posted in the company's Slack (`dev-tribe` channel) like this [one](https://rasa-hq.slack.com/archives/C01M5TAHDHA/p1701444735622919)
    (In this case do the following checks):
     - Check the workflows in [Github Actions](https://github.com/RasaHQ/rasa-private/actions) and make sure that the merged PR of the current release is completed successfully. To easily find your PR you can use the filters `event: push` and `branch: <version number>` (example on release 2.4 you can see [here](https://github.com/RasaHQ/rasa/actions/runs/643344876))
-    - If the workflow is not completed, then try to re run the workflow in case that solves the problem
+    - If the workflow is not completed, then try to re-run the workflow in case that solves the problem
     - If the problem persists, check also the log files and try to find the root cause of the issue
     - If you still cannot resolve the error, contact the infrastructure team by providing any helpful information from your investigation
+10. If the release is successful, add the newly created release branch to the backporting configuration in the `.backportrc.json` file to
+the `targetBranchesChoices` list. This is necessary for the backporting workflow to work correctly with new release branches.
+
 
 ### Cutting a Patch release
 

rasa/api.py

@@ -2,7 +2,7 @@ import asyncio
 from typing import TYPE_CHECKING, Any, Dict, List, Optional, Text, Union
 
 import rasa.shared.constants
-from rasa.core.persistor import StorageType
+from rasa.nlu.persistor import StorageType
 
 # WARNING: Be careful about adding any top level imports at this place!
 #   These functions are imported in `rasa.__init__` and any top level import
@@ -14,7 +14,6 @@ from rasa.core.persistor import StorageType
 
 if TYPE_CHECKING:
     from rasa.model_training import TrainingResult
-    from rasa.shared.importers.importer import TrainingDataImporter
 
 
 def run(
@@ -79,7 +78,6 @@ def train(
     model_to_finetune: Optional[Text] = None,
     finetuning_epoch_fraction: float = 1.0,
     remote_storage: Optional[StorageType] = None,
-    file_importer: Optional["TrainingDataImporter"] = None,
 ) -> "TrainingResult":
     """Runs Rasa Core and NLU training in `async` loop.
 
@@ -101,10 +99,7 @@ def train(
             a directory in case the latest trained model should be used.
         finetuning_epoch_fraction: The fraction currently specified training epochs
             in the model configuration which should be used for finetuning.
-        remote_storage: Optional name of the remote storage to
-            use for storing the model.
-        file_importer: Instance of `TrainingDataImporter` to use for training.
-            If it is not provided, a new instance will be created.
+        remote_storage: Remote storage to use for model storage.
 
     Returns:
         An instance of `TrainingResult`.
@@ -126,7 +121,6 @@ def train(
             model_to_finetune=model_to_finetune,
             finetuning_epoch_fraction=finetuning_epoch_fraction,
             remote_storage=remote_storage,
-            file_importer=file_importer,
         )
     )
 

rasa/cli/arguments/default_arguments.py

@@ -1,9 +1,8 @@
 import argparse
 import logging
-from enum import Enum
-from typing import List, Optional, Text, Union
+from typing import Optional, Text, Union
 
-from rasa.core.persistor import RemoteStorageType, StorageType, parse_remote_storage
+from rasa.nlu.persistor import RemoteStorageType, StorageType, parse_remote_storage
 from rasa.shared.constants import (
     DEFAULT_CONFIG_PATH,
     DEFAULT_DATA_PATH,
@@ -186,23 +185,3 @@ def parse_remote_storage_arg(value: str) -> StorageType:
         return parse_remote_storage(value)
     except ValueError as e:
         raise argparse.ArgumentTypeError(str(e))
-
-
-class SkipYamlValidation(Enum):
-    DOMAIN = "domain"
-
-    @classmethod
-    def list(cls) -> List[str]:
-        return [e.value for e in SkipYamlValidation]
-
-
-def add_skip_validation_flag(
-    parser: Union[argparse.ArgumentParser, argparse._ActionsContainer],
-) -> None:
-    parser.add_argument(
-        "--skip-yaml-validation",
-        default=[],
-        choices=SkipYamlValidation.list(),
-        action="append",
-        help="Skip YAML validation for selected parts of the training data.",
-    )

rasa/cli/arguments/run.py

@@ -5,7 +5,6 @@ from typing import Union
 from rasa.cli.arguments.default_arguments import (
     add_endpoint_param,
     add_model_param,
-    add_skip_validation_flag,
     add_remote_storage_param,
 )
 from rasa.core import constants
@@ -22,7 +21,6 @@ def set_run_arguments(parser: argparse.ArgumentParser) -> None:
     """Arguments for running Rasa directly using `rasa run`."""
     add_model_param(parser)
     add_server_arguments(parser)
-    add_skip_validation_flag(parser)
 
 
 def set_run_action_arguments(parser: argparse.ArgumentParser) -> None:

rasa/cli/e2e_test.py

@@ -221,17 +221,15 @@ def execute_e2e_tests(args: argparse.Namespace) -> None:
     if args.e2e_results is not None:
         results_path = Path(args.e2e_results)
 
-        if passed:
-            passed_file = rasa.cli.utils.get_e2e_results_file_name(
-                results_path, STATUS_PASSED
-            )
-            write_test_results_to_file(passed, passed_file)
+        passed_file = rasa.cli.utils.get_e2e_results_file_name(
+            results_path, STATUS_PASSED
+        )
+        write_test_results_to_file(passed, passed_file)
 
-        if failed:
-            failed_file = rasa.cli.utils.get_e2e_results_file_name(
-                results_path, STATUS_FAILED
-            )
-            write_test_results_to_file(failed, failed_file)
+        failed_file = rasa.cli.utils.get_e2e_results_file_name(
+            results_path, STATUS_FAILED
+        )
+        write_test_results_to_file(failed, failed_file)
 
     aggregate_stats_calculator = AggregateTestStatsCalculator(
         passed_results=passed, failed_results=failed, test_cases=test_suite.test_cases

rasa/cli/inspect.py

@@ -3,12 +3,11 @@ import webbrowser
 from asyncio import AbstractEventLoop
 from typing import List, Text
 
-from sanic import Sanic
-
 from rasa.cli import SubParsersAction
 from rasa.cli.arguments import shell as arguments
-from rasa.cli.arguments.default_arguments import add_skip_validation_flag
 from rasa.core import constants
+from sanic import Sanic
+
 from rasa.utils.cli import remove_argument_from_parser
 
 
@@ -34,8 +33,6 @@ def add_subparser(
     inspect_parser.set_defaults(func=inspect)
 
     arguments.set_shell_arguments(inspect_parser)
-    add_skip_validation_flag(inspect_parser)
-
     # it'd be confusing to expose those arguments to the user,
     # so we remove them
     remove_argument_from_parser(inspect_parser, "--credentials")

rasa/cli/run.py

@@ -6,7 +6,6 @@ from typing import List, Text
 from rasa.api import run as rasa_run
 from rasa.cli import SubParsersAction
 from rasa.cli.arguments import run as arguments
-from rasa.cli.arguments.default_arguments import SkipYamlValidation
 from rasa.cli.utils import get_validated_path
 from rasa.exceptions import ModelNotFound
 from rasa.shared.constants import (
@@ -16,7 +15,6 @@ from rasa.shared.constants import (
     DEFAULT_MODELS_PATH,
     DOCS_BASE_URL,
 )
-from rasa.shared.core.domain import Domain
 from rasa.shared.utils.cli import print_error
 
 logger = logging.getLogger(__name__)
@@ -89,11 +87,6 @@ def run(args: argparse.Namespace) -> None:
         args.credentials, "credentials", DEFAULT_CREDENTIALS_PATH, True
     )
 
-    if SkipYamlValidation.DOMAIN.value in args.skip_yaml_validation:
-        Domain.validate_yaml = False
-    else:
-        Domain.validate_yaml = True
-
     if args.enable_api:
         if not args.remote_storage:
             args.model = _validate_model_path(args.model, "model", DEFAULT_MODELS_PATH)

rasa/cli/studio/studio.py

@@ -5,6 +5,7 @@ from urllib.parse import ParseResult, urlparse
 import questionary
 from rasa.cli import SubParsersAction
 
+import rasa.shared.utils.cli
 import rasa.cli.studio.download
 import rasa.cli.studio.train
 import rasa.cli.studio.upload
@@ -50,6 +51,15 @@ def _add_config_subparser(
 
     studio_config_parser.set_defaults(func=create_and_store_studio_config)
 
+    studio_config_parser.add_argument(
+        "--disable-verify",
+        "-x",
+        action="store_true",
+        default=False,
+        help="Disable strict SSL verification for the "
+        "Rasa Studio authentication server.",
+    )
+
     # add advanced configuration flag to trigger
     # advanced configuration setup for authentication settings
     studio_config_parser.add_argument(
@@ -219,7 +229,17 @@ def _configure_studio_config(args: argparse.Namespace) -> StudioConfig:
     studio_config = _create_studio_config(
         studio_url, keycloak_url, realm_name, client_id
     )
-    studio_auth = StudioAuth(studio_config)
+
+    if args.disable_verify:
+        rasa.shared.utils.cli.print_info(
+            "Disabling SSL verification for the Rasa Studio authentication server."
+        )
+        studio_auth = StudioAuth(studio_config, verify=False)
+    else:
+        rasa.shared.utils.cli.print_info(
+            "Enabling SSL verification for the Rasa Studio authentication server."
+        )
+        studio_auth = StudioAuth(studio_config, verify=True)
 
     if _check_studio_auth(studio_auth):
         return studio_config

rasa/cli/train.py

@@ -110,20 +110,16 @@ def run_training(args: argparse.Namespace, can_exit: bool = False) -> Optional[T
         for f in args.data
     ]
 
-    training_data_importer = TrainingDataImporter.load_from_config(
-        domain_path=domain, training_data_paths=args.data, config_path=config
-    )
-
     if not args.skip_validation:
         structlogger.info(
             "cli.train.run_training",
             event_info="Started validating domain and training data...",
         )
-
+        importer = TrainingDataImporter.load_from_config(
+            domain_path=domain, training_data_paths=args.data, config_path=config
+        )
         rasa.cli.utils.validate_files(
-            args.fail_on_validation_warnings,
-            args.validation_max_history,
-            training_data_importer,
+            args.fail_on_validation_warnings, args.validation_max_history, importer
         )
 
     training_result = train_all(
@@ -142,7 +138,6 @@ def run_training(args: argparse.Namespace, can_exit: bool = False) -> Optional[T
         model_to_finetune=_model_for_finetuning(args),
         finetuning_epoch_fraction=args.epoch_fraction,
         remote_storage=args.remote_storage,
-        file_importer=training_data_importer,
     )
     if training_result.code != 0 and can_exit:
         sys.exit(training_result.code)

rasa/cli/utils.py

@@ -470,10 +470,10 @@ def get_e2e_results_file_name(
 ) -> str:
     """Returns the name of the e2e results file."""
     if results_output_path.is_dir():
-        file_name = results_output_path / f"e2e_results_{result_type}.yml"
+        file_name = str(results_output_path) + f"/e2e_results_{result_type}.yml"
     else:
         parent = results_output_path.parent
         stem = results_output_path.stem
-        file_name = parent / f"{stem}_{result_type}.yml"
+        file_name = str(parent) + f"/{stem}_{result_type}.yml"
 
-    return str(file_name)
+    return file_name

rasa/core/agent.py

@@ -19,7 +19,6 @@ from rasa.core.exceptions import AgentNotReady
 from rasa.core.http_interpreter import RasaNLUHttpInterpreter
 from rasa.core.lock_store import InMemoryLockStore, LockStore
 from rasa.core.nlg import NaturalLanguageGenerator, TemplatedNaturalLanguageGenerator
-from rasa.core.persistor import StorageType
 from rasa.core.policies.policy import PolicyPrediction
 from rasa.core.processor import MessageProcessor
 from rasa.core.tracker_store import (
@@ -29,6 +28,7 @@ from rasa.core.tracker_store import (
 )
 from rasa.core.utils import AvailableEndpoints
 from rasa.exceptions import ModelNotFound
+from rasa.nlu.persistor import StorageType
 from rasa.nlu.utils import is_url
 from rasa.shared.constants import DEFAULT_SENDER_ID
 from rasa.shared.core.domain import Domain
@@ -544,7 +544,7 @@ class Agent:
 
     def load_model_from_remote_storage(self, model_name: Text) -> None:
         """Loads an Agent from remote storage."""
-        from rasa.core.persistor import get_persistor
+        from rasa.nlu.persistor import get_persistor
 
         persistor = get_persistor(self.remote_storage)
 

rasa/core/brokers/kafka.py

@@ -2,8 +2,6 @@ import asyncio
 import os
 import json
 import logging
-from functools import cached_property
-
 import structlog
 import threading
 from asyncio import AbstractEventLoop
@@ -272,7 +270,7 @@ class KafkaEventBroker(EventBroker):
         if self.producer:
             self.producer.flush()
 
-    @cached_property
+    @rasa.shared.utils.common.lazy_property
     def rasa_environment(self) -> Optional[Text]:
         """Get value of the `RASA_ENVIRONMENT` environment variable."""
         return os.environ.get("RASA_ENVIRONMENT", "RASA_ENVIRONMENT_NOT_SET")

rasa/core/brokers/pika.py

@@ -1,8 +1,6 @@
 import asyncio
 import json
 import logging
-from functools import cached_property
-
 import structlog
 import os
 import ssl
@@ -335,7 +333,7 @@ class PikaEventBroker(EventBroker):
             delivery_mode=aio_pika.DeliveryMode.PERSISTENT,
         )
 
-    @cached_property
+    @rasa.shared.utils.common.lazy_property
     def rasa_environment(self) -> Optional[Text]:
         """Get value of the `RASA_ENVIRONMENT` environment variable."""
         return os.environ.get("RASA_ENVIRONMENT")

rasa/core/channels/socketio.py

@@ -37,11 +37,7 @@ class SocketBlueprint(Blueprint):
         :param options: Options to be used while registering the
             blueprint into the app.
         """
-        if self.ctx.socketio_path:
-            path = self.ctx.socketio_path
-        else:
-            path = options.get("url_prefix", "/socket.io")
-        self.ctx.sio.attach(app, path)
+        self.ctx.sio.attach(app, self.ctx.socketio_path)
         super().register(app, options)
 
 

rasa/core/channels/voice_aware/utils.py

@@ -1,16 +1,15 @@
 import structlog
 
+from rasa.utils.licensing import (
+    PRODUCT_AREA,
+    VOICE_SCOPE,
+    validate_license_from_env,
+)
 
 structlogger = structlog.get_logger()
 
 
 def validate_voice_license_scope() -> None:
-    from rasa.utils.licensing import (
-        PRODUCT_AREA,
-        VOICE_SCOPE,
-        validate_license_from_env,
-    )
-
     """Validate that the correct license scope is present."""
     structlogger.info(
         f"Validating current Rasa Pro license scope which must include "

rasa/core/nlg/contextual_response_rephraser.py

@@ -1,13 +1,11 @@
 from typing import Any, Dict, Optional, Text
 
-import os
 import structlog
 from jinja2 import Template
 
 from rasa import telemetry
 from rasa.core.nlg.response import TemplatedNaturalLanguageGenerator
 from rasa.shared.constants import (
-    LLM_API_HEALTH_CHECK_ENV_VAR,
     LLM_CONFIG_KEY,
     MODEL_CONFIG_KEY,
     MODEL_NAME_CONFIG_KEY,
@@ -25,7 +23,6 @@ from rasa.shared.utils.llm import (
     USER,
     combine_custom_and_default_config,
     get_prompt_template,
-    llm_api_health_check,
     llm_factory,
     try_instantiate_llm_client,
 )
@@ -100,18 +97,12 @@ class ContextualResponseRephraser(TemplatedNaturalLanguageGenerator):
         self.trace_prompt_tokens = self.nlg_endpoint.kwargs.get(
             "trace_prompt_tokens", False
         )
-        llm_client = try_instantiate_llm_client(
+        try_instantiate_llm_client(
             self.nlg_endpoint.kwargs.get(LLM_CONFIG_KEY),
             DEFAULT_LLM_CONFIG,
             "contextual_response_rephraser.init",
-            ContextualResponseRephraser.__name__,
+            "ContextualResponseRephraser",
         )
-        if os.getenv(LLM_API_HEALTH_CHECK_ENV_VAR, "true").lower() == "true":
-            llm_api_health_check(
-                llm_client,
-                "contextual_response_rephraser.init",
-                ContextualResponseRephraser.__name__,
-            )
 
     def _last_message_if_human(self, tracker: DialogueStateTracker) -> Optional[str]:
         """Returns the latest message from the tracker.

rasa/core/policies/enterprise_search_policy.py

@@ -1,6 +1,5 @@
 import importlib.resources
 import json
-import os
 import re
 from typing import TYPE_CHECKING, Any, Dict, List, Optional, Text
 
@@ -48,7 +47,6 @@ from rasa.graph_components.providers.forms_provider import Forms
 from rasa.graph_components.providers.responses_provider import Responses
 from rasa.shared.constants import (
     EMBEDDINGS_CONFIG_KEY,
-    LLM_API_HEALTH_CHECK_ENV_VAR,
     LLM_CONFIG_KEY,
     MODEL_CONFIG_KEY,
     MODEL_NAME_CONFIG_KEY,
@@ -74,7 +72,6 @@ from rasa.shared.utils.llm import (
     DEFAULT_OPENAI_EMBEDDING_MODEL_NAME,
     embedder_factory,
     get_prompt_template,
-    llm_api_health_check,
     llm_factory,
     sanitize_message_for_prompt,
     tracker_as_readable_transcript,
@@ -295,18 +292,12 @@ class EnterpriseSearchPolicy(Policy):
             )
 
         # validate llm configuration
-        llm_client = try_instantiate_llm_client(
+        try_instantiate_llm_client(
             self.config.get(LLM_CONFIG_KEY),
             DEFAULT_LLM_CONFIG,
             "enterprise_search_policy.train",
-            EnterpriseSearchPolicy.__name__,
+            "EnterpriseSearchPolicy",
         )
-        if os.getenv(LLM_API_HEALTH_CHECK_ENV_VAR, "true").lower() == "true":
-            llm_api_health_check(
-                llm_client,
-                "enterprise_search_policy.train",
-                EnterpriseSearchPolicy.__name__,
-            )
 
         if store_type == DEFAULT_VECTOR_STORE_TYPE:
             logger.info("enterprise_search_policy.train.faiss")

rasa/core/policies/intentless_policy.py

@@ -1,6 +1,5 @@
 import importlib.resources
 import math
-import os
 from dataclasses import dataclass, field
 from typing import Any, Dict, List, Optional, Set, TYPE_CHECKING, Text, Tuple
 
@@ -32,7 +31,6 @@ from rasa.graph_components.providers.responses_provider import Responses
 from rasa.shared.constants import (
     REQUIRED_SLOTS_KEY,
     EMBEDDINGS_CONFIG_KEY,
-    LLM_API_HEALTH_CHECK_ENV_VAR,
     LLM_CONFIG_KEY,
     MODEL_CONFIG_KEY,
     MODEL_NAME_CONFIG_KEY,
@@ -69,7 +67,6 @@ from rasa.shared.utils.llm import (
     combine_custom_and_default_config,
     embedder_factory,
     get_prompt_template,
-    llm_api_health_check,
     llm_factory,
     sanitize_message_for_prompt,
     tracker_as_readable_transcript,
@@ -490,16 +487,12 @@ class IntentlessPolicy(Policy):
             A policy must return its resource locator so that potential children nodes
             can load the policy from the resource.
         """
-        llm_client = try_instantiate_llm_client(
+        try_instantiate_llm_client(
             self.config.get(LLM_CONFIG_KEY),
             DEFAULT_LLM_CONFIG,
             "intentless_policy.train",
-            IntentlessPolicy.__name__,
+            "IntentlessPolicy",
         )
-        if os.getenv(LLM_API_HEALTH_CHECK_ENV_VAR, "true").lower() == "true":
-            llm_api_health_check(
-                llm_client, "intentless_policy.train", IntentlessPolicy.__name__
-            )
 
         responses = filter_responses(responses, forms, flows or FlowsList([]))
         telemetry.track_intentless_policy_train()

rasa/core/processor.py

@@ -101,6 +101,9 @@ logger = logging.getLogger(__name__)
 structlogger = structlog.get_logger()
 
 MAX_NUMBER_OF_PREDICTIONS = int(os.environ.get("MAX_NUMBER_OF_PREDICTIONS", "10"))
+MAX_NUMBER_OF_PREDICTIONS_CALM = int(
+    os.environ.get("MAX_NUMBER_OF_PREDICTIONS_CALM", "1000")
+)
 
 
 class MessageProcessor:
@@ -114,6 +117,7 @@ class MessageProcessor:
         generator: NaturalLanguageGenerator,
         action_endpoint: Optional[EndpointConfig] = None,
         max_number_of_predictions: int = MAX_NUMBER_OF_PREDICTIONS,
+        max_number_of_predictions_calm: int = MAX_NUMBER_OF_PREDICTIONS_CALM,
         on_circuit_break: Optional[LambdaType] = None,
         http_interpreter: Optional[RasaNLUHttpInterpreter] = None,
         endpoints: Optional["AvailableEndpoints"] = None,
@@ -122,7 +126,6 @@ class MessageProcessor:
         self.nlg = generator
         self.tracker_store = tracker_store
         self.lock_store = lock_store
-        self.max_number_of_predictions = max_number_of_predictions
         self.on_circuit_break = on_circuit_break
         self.action_endpoint = action_endpoint
         self.model_filename, self.model_metadata, self.graph_runner = self._load_model(
@@ -130,6 +133,10 @@ class MessageProcessor:
         )
         self.endpoints = endpoints
 
+        self.max_number_of_predictions = max_number_of_predictions
+        self.max_number_of_predictions_calm = max_number_of_predictions_calm
+        self.is_calm_assistant = self._is_calm_assistant()
+
         if self.model_metadata.assistant_id is None:
             rasa.shared.utils.io.raise_warning(
                 f"The model metadata does not contain a value for the "
@@ -972,11 +979,15 @@ class MessageProcessor:
     ) -> int:
         """Select the action limit based on the tracker state.
 
-        Usually, we want to limit the number of predictions to the number of actions
-        that have been executed in the conversation so far. However, if the
-        conversation is currently in a state where the user is correcting the flow
-        we want to allow for more predictions to be made as we might be traversing
-        through a long flow.
+        This function determines the maximum number of predictions that should be
+        made during a dialogue conversation. Typically, the number of predictions
+        is limited to the number of actions executed so far in the conversation.
+        However, in certain states (e.g., when the user is correcting the
+        conversation flow), more predictions may be allowed as the system traverses
+        through a long dialogue flow.
+
+        Additionally, if the `ROUTE_TO_CALM_SLOT` is present in the tracker slots,
+        the action limit is adjusted to a separate limit for CALM-based flows.
 
         Args:
             tracker: instance of DialogueStateTracker.
@@ -984,6 +995,18 @@ class MessageProcessor:
         Returns:
         The maximum number of predictions to make.
         """
+        # Check if it is a CALM assistant and if so, that the `ROUTE_TO_CALM_SLOT`
+        # is either not present or set to `True`.
+        # If it does, use the specific prediction limit for CALM assistants.
+        # Otherwise, use the default prediction limit.
+        if self.is_calm_assistant and (
+            not tracker.has_coexistence_routing_slot
+            or tracker.get_slot(ROUTE_TO_CALM_SLOT)
+        ):
+            max_number_of_predictions = self.max_number_of_predictions_calm
+        else:
+            max_number_of_predictions = self.max_number_of_predictions
+
         reversed_events = list(tracker.events)[::-1]
         is_conversation_in_flow_correction = False
         for e in reversed_events:
@@ -998,8 +1021,10 @@ class MessageProcessor:
             # allow for more predictions to be made as we might be traversing through
             # a long flow. We multiply the number of predictions by 10 to allow for
             # more predictions to be made - the factor is a best guess.
-            return self.max_number_of_predictions * 5
-        return self.max_number_of_predictions
+            return max_number_of_predictions * 5
+
+        # Return the default
+        return max_number_of_predictions
 
     def is_action_limit_reached(
         self, tracker: DialogueStateTracker, should_predict_another_action: bool
@@ -1387,3 +1412,27 @@ class MessageProcessor:
         ]
 
         return len(filtered_commands) > 0
+
+    def _is_calm_assistant(self) -> bool:
+        """Inspects the nodes of the graph schema to determine whether
+        any node is associated with the `FlowPolicy`, which is indicative of a
+        CALM assistant setup.
+
+        Returns:
+            bool: True if any node in the graph schema uses `FlowPolicy`.
+        """
+        # Get the graph schema's nodes from the graph runner.
+        nodes: dict[str, Any] = self.graph_runner._graph_schema.nodes  # type: ignore[attr-defined]
+
+        flow_policy_class_path = "rasa.core.policies.flow_policy.FlowPolicy"
+        # Iterate over the nodes and check if any node uses `FlowPolicy`.
+        for node_name, schema_node in nodes.items():
+            if (
+                schema_node.uses is not None
+                and f"{schema_node.uses.__module__}.{schema_node.uses.__name__}"
+                == flow_policy_class_path
+            ):
+                return True
+
+        # Return False if no node is found using `FlowPolicy`.
+        return False