rasa-pro 3.13.12__py3-none-any.whl → 3.14.0__py3-none-any.whl

rasa/utils/tensorflow/models.py

@@ -8,7 +8,6 @@ from typing import TYPE_CHECKING, Any, Dict, List, Optional, Text, Tuple, Union
 import numpy as np
 import tensorflow as tf
 from keras import Model
-from keras.src.utils import tf_utils
 
 import rasa.utils.train_utils
 from rasa.shared.constants import DIAGNOSTIC_DATA
@@ -78,6 +77,7 @@ class RasaModel(Model):
 
         Args:
             random_seed: set the random seed to get reproducible results
+            **kwargs: Additional keyword arguments passed to the parent class
         """
         # make sure that keras releases resources from previously trained model
         tf.keras.backend.clear_session()
@@ -273,7 +273,8 @@ class RasaModel(Model):
         if self._run_eagerly:
             # Once we take advantage of TF's distributed training, this is where
             # scheduled functions will be forced to execute and return actual values.
-            outputs = tf_utils.sync_to_numpy_or_python_type(self.predict_step(batch_in))
+            step_output = self.predict_step(batch_in)
+            outputs = self._convert_tensors_to_numpy(step_output)
             if DIAGNOSTIC_DATA in outputs:
                 outputs[DIAGNOSTIC_DATA] = self._empty_lists_to_none_in_dict(
                     outputs[DIAGNOSTIC_DATA]
@@ -287,9 +288,8 @@ class RasaModel(Model):
 
         # Once we take advantage of TF's distributed training, this is where
         # scheduled functions will be forced to execute and return actual values.
-        outputs = tf_utils.sync_to_numpy_or_python_type(
-            self._tf_predict_step(list(batch_in))
-        )
+        step_output = self._tf_predict_step(list(batch_in))
+        outputs = self._convert_tensors_to_numpy(step_output)
         if DIAGNOSTIC_DATA in outputs:
             outputs[DIAGNOSTIC_DATA] = self._empty_lists_to_none_in_dict(
                 outputs[DIAGNOSTIC_DATA]
@@ -388,6 +388,35 @@ class RasaModel(Model):
 
         return {k: _recurse(v) for k, v in input_dict.items()}
 
+    def _convert_tensors_to_numpy(
+        self, step_output: Dict[Text, Any]
+    ) -> Dict[Text, Any]:
+        """ "Recursively convert TensorFlow tensors to numpy arrays for Keras 3.x
+        compatibility.
+        Replaces the deprecated tf_utils.sync_to_numpy_or_python_type() function.
+        Converts tensors (objects with 'numpy' method) to numpy arrays,
+        leaves others unchanged.
+        """
+
+        def to_numpy(obj: Any) -> Any:
+            if hasattr(obj, "numpy"):
+                try:
+                    return obj.numpy()
+                except Exception:
+                    # Fallback: return as-is if not convertible
+                    return obj
+            # Dict: recurse into values
+            if isinstance(obj, dict):
+                return {k: to_numpy(v) for k, v in obj.items()}
+            # List/Tuple: recurse preserving type
+            if isinstance(obj, list):
+                return [to_numpy(v) for v in obj]
+            if isinstance(obj, tuple):
+                return tuple(to_numpy(v) for v in obj)
+            return obj
+
+        return {key: to_numpy(value) for key, value in step_output.items()}
+
     def _get_metric_results(self, prefix: Optional[Text] = "") -> Dict[Text, float]:
         return {
             f"{prefix}{metric.name}": metric.result()
@@ -403,7 +432,21 @@ class RasaModel(Model):
             overwrite: If 'True' an already existing model with the same file name will
                        be overwritten.
         """
-        self.save_weights(model_file_name, overwrite=overwrite, save_format="tf")
+        # Ensure filename ends with .weights.h5 and model is built for Keras 3.x
+        # compatibility
+        model_file_name = str(model_file_name)
+        if not model_file_name.endswith(".weights.h5"):
+            model_file_name += ".weights.h5"
+
+        if not self.built:
+            import tensorflow as tf
+
+            _ = self(tf.zeros((1, 1)))
+
+        # TensorFlow 2.19: save weights with different file extension
+        if not model_file_name.endswith(".weights.h5"):
+            model_file_name += ".weights.h5"
+        self.save_weights(model_file_name, overwrite=overwrite)
 
     @classmethod
     def load(
@@ -438,18 +481,23 @@ class RasaModel(Model):
         learning_rate = kwargs.get("config", {}).get(LEARNING_RATE, 0.001)
         run_eagerly = kwargs.get("config", {}).get(RUN_EAGERLY)
 
-        # need to train on 1 example to build weights of the correct size
         model.compile(
             optimizer=tf.keras.optimizers.Adam(learning_rate), run_eagerly=run_eagerly
         )
         data_generator = RasaBatchDataGenerator(model_data_example, batch_size=1)
         model.fit(data_generator, verbose=False)
+
+        # Ensure model is built before loading weights
+        if not model.built:
+            sample_batch = next(iter(data_generator))
+            _ = model(sample_batch)
+
         # load trained weights
         model.load_weights(model_file_name)
 
         # predict on one data example to speed up prediction during inference
         # the first prediction always takes a bit longer to trace tf function
-        if not finetune_mode and predict_data_example:
+        if predict_data_example:
             model.run_inference(predict_data_example)
 
         logger.debug("Finished loading the model.")

rasa/utils/tensorflow/rasa_layers.py

@@ -291,7 +291,7 @@ class ConcatenateSparseDenseFeatures(RasaCustomLayer):
             [
                 config[DENSE_DIMENSION][attribute]
                 if signature.is_sparse
-                else signature.units
+                else (signature.units or 0)
                 for signature in feature_type_signature
             ]
         )
@@ -301,12 +301,12 @@ class ConcatenateSparseDenseFeatures(RasaCustomLayer):
     ) -> tf.Tensor:
         """Turns sparse tensor into dense, possibly adds dropout before and/or after."""
         if self.SPARSE_DROPOUT in self._tf_layers:
-            feature = self._tf_layers[self.SPARSE_DROPOUT](feature, training)
+            feature = self._tf_layers[self.SPARSE_DROPOUT](feature, training=training)
 
         feature = self._tf_layers[self.SPARSE_TO_DENSE](feature)
 
         if self.DENSE_DROPOUT in self._tf_layers:
-            feature = self._tf_layers[self.DENSE_DROPOUT](feature, training)
+            feature = self._tf_layers[self.DENSE_DROPOUT](feature, training=training)
 
         return feature
 
@@ -944,7 +944,7 @@ class RasaSequenceLayer(RasaCustomLayer):
         # Note that only sequence-level features are masked, nothing happens to the
         # sentence-level features in the combined features tensor.
         seq_sent_features, mlm_boolean_mask = self._tf_layers[self.MLM_INPUT_MASK](
-            seq_sent_features, mask_sequence, training
+            seq_sent_features, mask_sequence, training=training
         )
 
         return seq_sent_features, token_ids, mlm_boolean_mask
@@ -1002,7 +1002,9 @@ class RasaSequenceLayer(RasaCustomLayer):
         ]((sequence_features, sentence_features, sequence_feature_lengths))
 
         # Apply one or more dense layers.
-        seq_sent_features = self._tf_layers[self.FFNN](seq_sent_features, training)
+        seq_sent_features = self._tf_layers[self.FFNN](
+            seq_sent_features, training=training
+        )
 
         # If using masked language modeling, mask the transformer inputs and get labels
         # for the masked tokens and a boolean mask. Note that TED does not use MLM loss,
@@ -1031,7 +1033,7 @@ class RasaSequenceLayer(RasaCustomLayer):
         if self._has_transformer:
             mask_padding = 1 - mask_combined_sequence_sentence
             outputs, attention_weights = self._tf_layers[self.TRANSFORMER](
-                seq_sent_features_masked, mask_padding, training
+                seq_sent_features_masked, mask_padding, training=training
             )
             outputs = tf.nn.gelu(outputs)
         else:

rasa/utils/tensorflow/transformer.py

@@ -2,10 +2,8 @@ from typing import Optional, Text, Tuple, Union
 
 import numpy as np
 import tensorflow as tf
-
-# TODO: The following is not (yet) available via tf.keras
-from keras.src.utils.control_flow_util import smart_cond
 from tensorflow.keras import backend as K
+from tensorflow.python.keras.utils.control_flow_util import smart_cond
 
 from rasa.utils.tensorflow.exceptions import TFLayerConfigException
 from rasa.utils.tensorflow.layers import RandomlyConnectedDense
@@ -280,6 +278,7 @@ class MultiHeadAttention(tf.keras.layers.Layer):
             value: A tensor with shape (..., length, depth).
             pad_mask: Float tensor with shape broadcastable
                 to (..., length, length). Defaults to None.
+            training: A tensor
 
         Returns:
             output: A tensor with shape (..., length, depth).

rasa/utils/train_utils.py

@@ -11,29 +11,57 @@ from rasa.nlu.constants import NUMBER_OF_SUB_TOKENS
 from rasa.shared.constants import NEXT_MAJOR_VERSION_FOR_DEPRECATIONS
 from rasa.shared.exceptions import InvalidConfigException
 from rasa.shared.nlu.constants import SPLIT_ENTITIES_BY_COMMA
-from rasa.utils.tensorflow.callback import RasaModelCheckpoint, RasaTrainingLogger
-from rasa.utils.tensorflow.constants import (
-    AUTO,
-    CHECKPOINT_MODEL,
-    CONSTRAIN_SIMILARITIES,
-    COSINE,
-    CROSS_ENTROPY,
-    EPOCHS,
-    EVAL_NUM_EPOCHS,
-    EVAL_NUM_EXAMPLES,
-    INNER,
-    LOSS_TYPE,
-    MARGIN,
-    MODEL_CONFIDENCE,
-    RANKING_LENGTH,
-    RENORMALIZE_CONFIDENCES,
-    SEQUENCE,
-    SIMILARITY_TYPE,
-    SOFTMAX,
-    TOLERANCE,
-)
-from rasa.utils.tensorflow.data_generator import RasaBatchDataGenerator
-from rasa.utils.tensorflow.model_data import RasaModelData
+from rasa.utils.tensorflow import TENSORFLOW_AVAILABLE
+
+# Conditional imports for TensorFlow-dependent modules
+if TENSORFLOW_AVAILABLE:
+    from rasa.utils.tensorflow.callback import RasaModelCheckpoint, RasaTrainingLogger
+    from rasa.utils.tensorflow.constants import (
+        AUTO,
+        CHECKPOINT_MODEL,
+        CONSTRAIN_SIMILARITIES,
+        COSINE,
+        CROSS_ENTROPY,
+        EPOCHS,
+        EVAL_NUM_EPOCHS,
+        EVAL_NUM_EXAMPLES,
+        INNER,
+        LOSS_TYPE,
+        MARGIN,
+        MODEL_CONFIDENCE,
+        RANKING_LENGTH,
+        RENORMALIZE_CONFIDENCES,
+        SEQUENCE,
+        SIMILARITY_TYPE,
+        SOFTMAX,
+        TOLERANCE,
+    )
+    from rasa.utils.tensorflow.data_generator import RasaBatchDataGenerator
+    from rasa.utils.tensorflow.model_data import RasaModelData
+else:
+    # Placeholder values when TensorFlow is not available
+    RasaModelCheckpoint = None  # type: ignore
+    RasaTrainingLogger = None  # type: ignore
+    RasaBatchDataGenerator = None  # type: ignore
+    RasaModelData = None  # type: ignore
+    AUTO = "auto"
+    CHECKPOINT_MODEL = "checkpoint_model"
+    CONSTRAIN_SIMILARITIES = "constrain_similarities"
+    COSINE = "cosine"
+    CROSS_ENTROPY = "cross_entropy"
+    EPOCHS = "epochs"
+    EVAL_NUM_EPOCHS = "eval_num_epochs"
+    EVAL_NUM_EXAMPLES = "eval_num_examples"
+    INNER = "inner"
+    LOSS_TYPE = "loss_type"
+    MARGIN = "margin"
+    MODEL_CONFIDENCE = "model_confidence"
+    RANKING_LENGTH = "ranking_length"
+    RENORMALIZE_CONFIDENCES = "renormalize_confidences"
+    SEQUENCE = "sequence"
+    SIMILARITY_TYPE = "similarity_type"
+    SOFTMAX = "softmax"
+    TOLERANCE = "tolerance"
 
 if TYPE_CHECKING:
     from tensorflow.keras.callbacks import Callback
@@ -87,7 +115,9 @@ def rank_and_mask(
 
 
 def update_similarity_type(config: Dict[Text, Any]) -> Dict[Text, Any]:
-    """If SIMILARITY_TYPE is set to 'auto', update the SIMILARITY_TYPE depending
+    """Function to update the similarity type in the model configuration.
+
+    If SIMILARITY_TYPE is set to 'auto', update the SIMILARITY_TYPE depending
     on the LOSS_TYPE.
 
     Args:

rasa/validator.py

@@ -4,16 +4,16 @@ import string
 from collections import defaultdict
 from typing import Any, Dict, List, Optional, Set, Text, Tuple
 
+import jinja2.exceptions
 import structlog
 from jinja2 import Template
-from pypred import Predicate
 from pypred.ast import CompareOperator, Literal, NegateOperator
 
 import rasa.core.training.story_conflict
 import rasa.shared.nlu.constants
-import rasa.shared.utils.cli
-import rasa.shared.utils.io
+from rasa.agents.validation import validate_agent_names_not_conflicting_with_flows
 from rasa.core.channels import UserMessage
+from rasa.core.config.configuration import Configuration
 from rasa.dialogue_understanding.stack.frames import PatternFlowStackFrame
 from rasa.engine.language import Language
 from rasa.exceptions import ValidationError
@@ -70,10 +70,11 @@ from rasa.shared.core.training_data.structures import StoryGraph
 from rasa.shared.data import create_regex_pattern_reader
 from rasa.shared.exceptions import RasaException
 from rasa.shared.importers.importer import TrainingDataImporter
-from rasa.shared.nlu.constants import COMMANDS
+from rasa.shared.nlu.constants import COMMANDS, INTENT
 from rasa.shared.nlu.training_data.message import Message
 from rasa.shared.nlu.training_data.training_data import TrainingData
 from rasa.telemetry import track_validation_error_log
+from rasa.utils.pypred import Predicate
 
 logger = logging.getLogger(__name__)
 
@@ -130,7 +131,7 @@ class Validator:
         """Compares list of intents in domain with intents in NLU training data."""
         everything_is_alright = True
 
-        nlu_data_intents = {e.data["intent"] for e in self.intents.intent_examples}
+        nlu_data_intents = {e.data[INTENT] for e in self.intents.intent_examples}
 
         for intent in self._non_default_intents():
             if intent not in nlu_data_intents:
@@ -172,7 +173,7 @@ class Validator:
         duplication_hash = defaultdict(set)
         for example in self.intents.intent_examples:
             text = example.get(rasa.shared.nlu.constants.TEXT)
-            duplication_hash[text].add(example.get("intent"))
+            duplication_hash[text].add(example.get(INTENT))
 
         for text, intents in duplication_hash.items():
             if len(duplication_hash[text]) > 1:
@@ -629,11 +630,14 @@ class Validator:
         flow_id: str,
     ) -> bool:
         """Validates that a collect step can have either an action or an utterance.
+
         Also logs an error if neither an action nor an utterance is defined.
 
         Args:
             collect: the name of the slot to collect
             all_good: boolean value indicating the validation status
+            domain_slots: dictionary of domain slots
+            flow_id: the ID of the flow being validated
 
         Returns:
             False, if validation failed, true, otherwise
@@ -682,9 +686,10 @@ class Validator:
                 has_action_defined=has_action_defined,
                 flow=flow_id,
                 event_info=(
-                    f"The collect step '{collect.collect}' has neither an utterance "
-                    f"nor an action defined, or an initial value defined in the domain."
-                    f"You need to define either an utterance or an action."
+                    f"The collect step '{collect.collect}' has neither a response "
+                    f"nor an action defined, nor an initial value defined in the "
+                    f"domain. You can fix this by adding a response named "
+                    f"'{collect.utter}' used in the collect step."
                 ),
             )
             all_good = False
@@ -1179,23 +1184,27 @@ class Validator:
                         )
 
                 if isinstance(step, CollectInformationFlowStep):
-                    predicates = [predicate.if_ for predicate in step.rejections]
-                    for predicate in predicates:
+                    dumped_predicates = [predicate.if_ for predicate in step.rejections]
+                    for dumped_predicate in dumped_predicates:
                         all_good = self._verify_namespaces(
-                            predicate, step.id, flow.id, all_good
+                            dumped_predicate, step.id, flow.id, all_good
                         )
 
-                        pred, all_good = self._construct_predicate(
-                            predicate, step.id, context, is_step=True, all_good=all_good
+                        predicate, all_good = self._construct_predicate(
+                            dumped_predicate,
+                            step.id,
+                            context,
+                            is_step=True,
+                            all_good=all_good,
                         )
-                        if pred and not pred.is_valid():
+                        if predicate and not predicate.is_valid():
                             structlogger.error(
                                 "validator.verify_predicates.invalid_rejection",
                                 step=step.id,
                                 rejection=predicate,
                                 flow=flow.id,
                                 event_info=(
-                                    f"Detected invalid rejection '{predicate}' "
+                                    f"Detected invalid rejection '{dumped_predicate}' "
                                     f"at `collect` step '{step.id}' "
                                     f"for flow id '{flow.id}'. "
                                     f"Please make sure that all conditions are valid."
@@ -1280,6 +1289,41 @@ class Validator:
 
         return all_good
 
+    def validate_agent_flow_conflicts(self, sub_agents_path: str) -> bool:
+        """Validates that agent names don't conflict with flow names.
+
+        Args:
+            sub_agents_path: Path to the sub-agents directory.
+
+        Returns:
+            True if validation passes, False otherwise.
+        """
+        if self.flows.is_empty():
+            return True
+
+        try:
+            configuration = Configuration.get_instance()
+            available_agents = configuration.available_agents
+            flow_names = {flow.id for flow in self.flows.underlying_flows}
+
+            structlogger.debug(
+                "validator.agent_flow_conflicts.debug",
+                event_info="Checking conflicts between agents and flows",
+            )
+
+            validate_agent_names_not_conflicting_with_flows(
+                available_agents.agents, flow_names
+            )
+            return True
+        except Exception as e:
+            structlogger.error(
+                "validator.agent_flow_conflicts",
+                sub_agents_path=sub_agents_path,
+                error=str(e),
+                event_info=f"Agent-flow name conflict validation failed: {e}",
+            )
+            return False
+
     def _get_response_translation_warnings(self) -> list:
         """Collect warnings for responses missing translations.
 
@@ -1932,6 +1976,95 @@ class Validator:
 
         return all_good
 
+    def verify_prompt_templates(self) -> bool:
+        """Verify that all prompt templates have valid Jinja2 syntax.
+
+        Returns:
+            True if all templates are valid, False otherwise.
+        """
+        all_good = True
+
+        # Check the components in the pipeline and policies for prompt templates
+        pipeline = self.config.get(CONFIG_PIPELINE_KEY, [])
+        for component in pipeline:
+            if isinstance(component, dict):
+                component_name = component.get("name", "")
+                prompt_template = component.get("prompt_template")
+                if prompt_template:
+                    all_good = (
+                        self._validate_template_file(
+                            prompt_template, component_name, "pipeline component"
+                        )
+                        and all_good
+                    )
+
+        # Check policies for prompt templates
+        policies = self.config.get("policies") or []
+        for policy in policies:
+            if isinstance(policy, dict):
+                policy_name = policy.get("name", "")
+                prompt_template = policy.get("prompt_template")
+                if prompt_template:
+                    all_good = (
+                        self._validate_template_file(
+                            prompt_template, policy_name, "policy"
+                        )
+                        and all_good
+                    )
+
+        return all_good
+
+    def _validate_template_file(
+        self, prompt_template: str, component_name: str, component_type: str
+    ) -> bool:
+        """Validate a single prompt template file.
+
+        Args:
+            prompt_template: The template file path to validate
+            component_name: Name of the component using the template
+            component_type: Type of component (e.g., "policy", "pipeline component")
+
+        Returns:
+            True if template is valid, False otherwise.
+        """
+        try:
+            # Use a simple default template, as we're assuming
+            # that the default templates are valid
+            default_template = "{{ content }}"
+            template_content = rasa.shared.utils.llm.get_prompt_template(
+                prompt_template,
+                default_template,
+                log_source_component=f"validator.{component_name}",
+                log_source_method="init",
+            )
+
+            # Validate Jinja2 syntax using the shared validation function
+            rasa.shared.utils.llm.validate_jinja2_template(template_content)
+            return True
+        except jinja2.exceptions.TemplateSyntaxError as e:
+            structlogger.error(
+                "validator.verify_prompt_templates.syntax_error",
+                component=component_name,
+                component_type=component_type,
+                event_info=(
+                    f"Invalid Jinja2 template syntax in file {prompt_template} "
+                    f"at line {e.lineno}: {e.message}"
+                ),
+                error=str(e),
+                template_line=e.lineno,
+                template_file=prompt_template,
+            )
+            return False
+        except Exception as e:
+            structlogger.error(
+                "validator.verify_prompt_templates.error",
+                component=component_name,
+                component_type=component_type,
+                event_info=f"Error validating prompt template: {e}",
+                error=str(e),
+            )
+            return False
+
     def validate_conditional_response_variation_predicates(self) -> bool:
         """Validate the conditional response variation predicates."""
         context = {SLOTS: {slot.name: None for slot in self.domain.slots}}

rasa/version.py

@@ -1,3 +1,3 @@
 # this file will automatically be changed,
 # do not add anything but the version number here!
-__version__ = "3.13.12"
+__version__ = "3.14.0"