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

rasa/core/policies/flows/mcp_tool_executor.py

@@ -0,0 +1,304 @@
+import json
+from datetime import timedelta
+from typing import Any, Dict, List, Optional
+
+import structlog
+from jinja2.sandbox import SandboxedEnvironment
+from mcp.types import CallToolResult
+
+from rasa.core.config.configuration import Configuration
+from rasa.core.policies.flows.flow_step_result import (
+    ContinueFlowWithNextStep,
+    FlowStepResult,
+)
+from rasa.dialogue_understanding.patterns.internal_error import (
+    InternalErrorPatternFlowStackFrame,
+)
+from rasa.dialogue_understanding.stack.dialogue_stack import DialogueStack
+from rasa.shared.core.events import Event, SlotSet
+from rasa.shared.core.flows.steps import CallFlowStep
+from rasa.shared.core.trackers import DialogueStateTracker
+from rasa.shared.utils.mcp.server_connection import MCPServerConnection
+from rasa.utils.common import ensure_jsonified_iterable
+
+structlogger = structlog.get_logger()
+
+CONFIG_VALUE = "value"
+CONFIG_SLOT = "slot"
+TOOL_CALL_DEFATULT_TIMEOUT = 10  # seconds
+
+
+async def call_mcp_tool(
+    initial_events: List[Event],
+    stack: DialogueStack,
+    step: CallFlowStep,
+    tracker: DialogueStateTracker,
+) -> FlowStepResult:
+    """Run an MCP tool call step."""
+    structlogger.debug(
+        "flow.step.call_mcp_tool",
+        tool_id=step.call,
+        mcp_server=step.mcp_server,
+        mapping=step.mapping,
+        step_id=step.id,
+        flow_id=step.flow_id,
+        json_formatting=["mapping"],
+    )
+
+    try:
+        return await _execute_mcp_tool_call(initial_events, stack, step, tracker)
+    except Exception as e:
+        return _handle_mcp_tool_error(
+            stack,
+            initial_events,
+            error_message=f"Failed to execute MCP tool call: {e}.",
+            tool_name=step.call,
+            mcp_server=step.mcp_server,
+        )
+
+
+async def _execute_mcp_tool_call(
+    initial_events: List[Event],
+    stack: DialogueStack,
+    step: CallFlowStep,
+    tracker: DialogueStateTracker,
+) -> FlowStepResult:
+    """Execute the MCP tool call with proper error handling."""
+    mcp_server_connection = None
+    try:
+        # Connect to the MCP server
+        mcp_server_connection = await _connect_to_mcp_server(step.mcp_server)
+
+        if not mcp_server_connection:
+            return _handle_mcp_tool_error(
+                stack,
+                initial_events,
+                f"Cannot connect to MCP server '{step.mcp_server}'.",
+                tool_name=step.call,
+                mcp_server=step.mcp_server,
+            )
+
+        # Validate tool availability
+        if not await _is_tool_available(mcp_server_connection, step.call):
+            return _handle_mcp_tool_error(
+                stack,
+                initial_events,
+                f"Tool '{step.call}' is not available on MCP server "
+                f"'{step.mcp_server}'.",
+                tool_name=step.call,
+                mcp_server=step.mcp_server,
+            )
+
+        # This should not happen, but we need to check for type checking to pass
+        if not step.mapping:
+            return _handle_mcp_tool_error(
+                stack,
+                initial_events,
+                f"No mapping found for tool '{step.call}'.",
+                tool_name=step.call,
+                mcp_server=step.mcp_server,
+            )
+
+        # Prepare arguments for the tool call
+        arguments = _prepare_tool_arguments(step.mapping["input"], tracker)
+
+        # Call the tool with parameters
+        mcp_server = await mcp_server_connection.ensure_active_session()
+        result = await mcp_server.call_tool(
+            step.call,
+            arguments,
+            read_timeout_seconds=timedelta(seconds=TOOL_CALL_DEFATULT_TIMEOUT),
+        )
+
+        # Handle tool execution result
+        if result is None or result.isError:
+            return _handle_mcp_tool_error(
+                stack,
+                initial_events,
+                f"Tool '{step.call}' execution failed: {result.content}.",
+                tool_name=step.call,
+                mcp_server=step.mcp_server,
+            )
+        elif not result.content:
+            structlogger.warning(
+                "call_mcp_tool.empty_tool_result",
+                tool_name=step.call,
+                mcp_server=step.mcp_server,
+            )
+        else:
+            structlogger.debug(
+                "call_mcp_tool.tool_execution_success",
+                tool_name=step.call,
+                mcp_server=step.mcp_server,
+                result_content=result.content,
+                result_structured_content=result.structuredContent,
+                json_formatting=["result_content", "result_structured_content"],
+            )
+
+            # Process successful result
+            if set_slot_event := _process_tool_result(result, step.mapping["output"]):
+                initial_events.extend(set_slot_event)
+            else:
+                return _handle_mcp_tool_error(
+                    stack,
+                    initial_events,
+                    f"Failed to process tool result for '{step.call}'.",
+                    tool_name=step.call,
+                    mcp_server=step.mcp_server,
+                )
+
+        return ContinueFlowWithNextStep(events=initial_events)
+
+    finally:
+        # Always clean up the connection to prevent resource leaks
+        if mcp_server_connection:
+            try:
+                await mcp_server_connection.close()
+            except Exception as e:
+                structlogger.warning(
+                    "call_mcp_tool.connection_cleanup_failed",
+                    tool_name=step.call,
+                    mcp_server=step.mcp_server,
+                    error=str(e),
+                )
+
+
+async def _is_tool_available(
+    mcp_server_connection: MCPServerConnection, tool_name: str
+) -> bool:
+    """Check if the specified tool is available on the MCP server."""
+    try:
+        # Get the active session from the connection
+        mcp_server = await mcp_server_connection.ensure_active_session()
+        available_tools = await mcp_server.list_tools()
+        tool_names = [tool.name for tool in available_tools.tools]
+        return tool_name in tool_names
+    except Exception as e:
+        structlogger.warning(
+            "call_mcp_tool.tool_availability_check_failed",
+            tool_name=tool_name,
+            error=str(e),
+        )
+        return False
+
+
+async def _connect_to_mcp_server(
+    mcp_server_name: Optional[str],
+) -> Optional[MCPServerConnection]:
+    """Connect to the MCP server."""
+    if not mcp_server_name:
+        return None
+
+    # get the MCP server config from the available endpoints
+    endpoints = Configuration.get_instance().endpoints
+    mcp_servers = endpoints.mcp_servers
+    if not mcp_servers:
+        return None
+
+    mcp_server_configs = [
+        mcp_server for mcp_server in mcp_servers if mcp_server.name == mcp_server_name
+    ]
+    if not mcp_server_configs or len(mcp_server_configs) != 1:
+        return None
+
+    mcp_server_config = mcp_server_configs[0]
+
+    mcp_server_connection = MCPServerConnection.from_config(
+        mcp_server_config.model_dump()
+    )
+
+    # Ensure the connection is established and return the connection object
+    await mcp_server_connection.ensure_active_session()
+    return mcp_server_connection
+
+
+def _prepare_tool_arguments(
+    input_mapping: List[Dict[str, str]], tracker: DialogueStateTracker
+) -> Dict[str, Any]:
+    """Prepare arguments for the tool call from slot values."""
+    arguments = {}
+    for argument in input_mapping:
+        slot_value = tracker.get_slot(argument["slot"])
+        arguments[argument["param"]] = slot_value
+    return arguments
+
+
+def _jsonify_slot_value(value: Any) -> str | int | float | bool | None:
+    """Prepare value for SlotSet: iterables -> JSON string, primitives -> as-is"""
+    if isinstance(value, (list, dict)) and len(value):
+        return json.dumps(ensure_jsonified_iterable(value))
+    return value
+
+
+def _get_slot_value_from_jinja2_expression(
+    result_expression: str,
+    result_as_dict: Dict[str, Any],
+) -> Any:
+    """Get the slot value from the Jinja2 expression"""
+    # Create a sandboxed environment to evaluate the expression
+    _env = SandboxedEnvironment()
+
+    # Compile the expression
+    compiled_expr = _env.compile_expression(result_expression)
+
+    # Evaluate the expression
+    return compiled_expr(result_as_dict)
+
+
+def _process_tool_result(
+    result: CallToolResult,
+    output_mapping: List[Dict[str, str]],
+) -> Optional[List[SlotSet]]:
+    """Create a SetSlot event for the tool result using Jinja2 expressions"""
+    try:
+        _result_as_dict = {"result": result.model_dump()}
+        slots = []
+        for mapping in output_mapping:
+            try:
+                result_expression = mapping[CONFIG_VALUE]
+
+                # Get the slot value from the Jinja2 expression
+                slot_value = _get_slot_value_from_jinja2_expression(
+                    result_expression, _result_as_dict
+                )
+
+                slots.append(
+                    SlotSet(mapping[CONFIG_SLOT], _jsonify_slot_value(slot_value))
+                )
+            except Exception as e:
+                structlogger.error(
+                    "call_mcp_tool.value_not_found_in_tool_result",
+                    slot=mapping[CONFIG_SLOT],
+                    value=mapping[CONFIG_VALUE],
+                    result=_result_as_dict,
+                    error=str(e),
+                    json_formatting=["result"],
+                )
+                return None
+        return slots
+    except Exception as e:
+        structlogger.error(
+            "call_mcp_tool.result_processing_failed",
+            error=str(e),
+            result=result,
+            json_formatting=["result"],
+        )
+        return None
+
+
+def _handle_mcp_tool_error(
+    stack: DialogueStack,
+    events: List[Event],
+    error_message: str,
+    tool_name: str,
+    mcp_server: Optional[str],
+) -> FlowStepResult:
+    """Handle MCP tool errors consistently."""
+    structlogger.error(
+        "call_mcp_tool.error",
+        error_message=error_message,
+        tool_name=tool_name,
+        mcp_server=mcp_server,
+    )
+    stack.push(InternalErrorPatternFlowStackFrame())
+    return ContinueFlowWithNextStep(events=events)

rasa/core/policies/intentless_policy.py

@@ -5,7 +5,7 @@ from typing import TYPE_CHECKING, Any, Dict, List, Optional, Text, Tuple
 
 import structlog
 import tiktoken
-from deprecated import deprecated  # type: ignore[import]
+from deprecated import deprecated  # type: ignore[import-untyped]
 from jinja2 import Template
 from langchain.docstore.document import Document
 from langchain.schema.embeddings import Embeddings

rasa/core/policies/rule_policy.py

@@ -84,7 +84,7 @@ class InvalidRule(RasaException):
     """Exception that can be raised when rules are not valid."""
 
     def __init__(self, message: Text) -> None:
-        super().__init__()
+        super().__init__(message)
         self.message = message
 
     def __str__(self) -> Text:

rasa/core/policies/ted_policy.py

@@ -58,6 +58,7 @@ from rasa.shared.nlu.training_data.features import (
     save_features,
 )
 from rasa.shared.nlu.training_data.message import Message
+from rasa.shared.utils.io import raise_deprecation_warning
 from rasa.utils import train_utils
 from rasa.utils.tensorflow import rasa_layers
 from rasa.utils.tensorflow.constants import (
@@ -80,7 +81,6 @@ from rasa.utils.tensorflow.constants import (
     EMBEDDING_DIMENSION,
     ENCODING_DIMENSION,
     ENTITY_RECOGNITION,
-    EPOCH_OVERRIDE,
     EPOCHS,
     EVAL_NUM_EPOCHS,
     EVAL_NUM_EXAMPLES,
@@ -363,6 +363,9 @@ class TEDPolicy(Policy):
         entity_tag_specs: Optional[List[EntityTagSpec]] = None,
     ) -> None:
         """Declares instance variables with default values."""
+        raise_deprecation_warning(
+            "TEDPolicy is deprecated and will be removed in a future version."
+        )
         super().__init__(
             config, model_storage, resource, execution_context, featurizer=featurizer
         )
@@ -668,6 +671,7 @@ class TEDPolicy(Policy):
             self.model.compile(
                 optimizer=tf.keras.optimizers.Adam(self.config[LEARNING_RATE])
             )
+
         (
             data_generator,
             validation_data_generator,
@@ -943,14 +947,16 @@ class TEDPolicy(Policy):
 
         with self._model_storage.write_to(self._resource) as model_path:
             model_filename = self._metadata_filename()
-            tf_model_file = model_path / f"{model_filename}.tf_model"
+            tf_model_file = model_path / f"{model_filename}.weights.h5"
 
             rasa.shared.utils.io.create_directory_for_file(tf_model_file)
 
             self.featurizer.persist(model_path)
 
             if self.config[CHECKPOINT_MODEL] and self.tmp_checkpoint_dir:
-                self.model.load_weights(self.tmp_checkpoint_dir / "checkpoint.tf_model")
+                self.model.load_weights(
+                    self.tmp_checkpoint_dir / "checkpoint.weights.h5"
+                )
                 # Save an empty file to flag that this model has been
                 # produced using checkpointing
                 checkpoint_marker = model_path / f"{model_filename}.from_checkpoint.pkl"
@@ -1009,7 +1015,7 @@ class TEDPolicy(Policy):
         Args:
             model_path: Path where model is to be persisted.
         """
-        tf_model_file = model_path / f"{cls._metadata_filename()}.tf_model"
+        tf_model_file = model_path / f"{cls._metadata_filename()}.weights.h5"
 
         # load data example
         loaded_data = deserialize_nested_feature_arrays(
@@ -1109,8 +1115,6 @@ class TEDPolicy(Policy):
         model_utilities = cls._load_model_utilities(model_path)
 
         config = cls._update_loaded_params(config)
-        if execution_context.is_finetuning and EPOCH_OVERRIDE in config:
-            config[EPOCHS] = config.get(EPOCH_OVERRIDE)
 
         (
             model_data_example,
@@ -1125,7 +1129,6 @@ class TEDPolicy(Policy):
                 model_data_example,
                 predict_data_example,
                 featurizer,
-                execution_context.is_finetuning,
             )
 
         return cls._load_policy_with_model(
@@ -1167,7 +1170,6 @@ class TEDPolicy(Policy):
         model_data_example: RasaModelData,
         predict_data_example: RasaModelData,
         featurizer: TrackerFeaturizer,
-        should_finetune: bool,
     ) -> TED:
         model = cls.model_class().load(
             str(model_utilities["tf_model_file"]),
@@ -1180,7 +1182,9 @@ class TEDPolicy(Policy):
             ),
             label_data=model_utilities["label_data"],
             entity_tag_specs=model_utilities["entity_tag_specs"],
-            finetune_mode=should_finetune,
+            # This feature is no longer supported as the updated version
+            # of Keras does not allow updating a compiled model anymore.
+            finetune_mode=False,
         )
         return model
 
@@ -1463,7 +1467,7 @@ class TED(TransformerRasaModel):
 
         dialogue_transformed, attention_weights = self._tf_layers[
             f"transformer.{DIALOGUE}"
-        ](dialogue_in, 1 - mask, self._training)
+        ](dialogue_in, 1 - mask, training=self._training)
         dialogue_transformed = tf.nn.gelu(dialogue_transformed)
 
         if self.max_history_featurizer_is_used:
@@ -1708,7 +1712,7 @@ class TED(TransformerRasaModel):
 
         if attribute in SENTENCE_FEATURES_TO_ENCODE + LABEL_FEATURES_TO_ENCODE:
             attribute_features = self._tf_layers[f"encoding_layer.{attribute}"](
-                attribute_features, self._training
+                attribute_features, training=self._training
             )
 
         # attribute features have shape
@@ -2102,7 +2106,11 @@ class TED(TransformerRasaModel):
         predictions = {
             "scores": scores,
             "similarities": sim_all,
-            DIAGNOSTIC_DATA: {"attention_weights": attention_weights},
+            DIAGNOSTIC_DATA: {
+                "attention_weights": attention_weights.numpy()
+                if attention_weights is not None and hasattr(attention_weights, "numpy")
+                else attention_weights,
+            },
         }
 
         if (

rasa/core/policies/unexpected_intent_policy.py

@@ -54,6 +54,7 @@ from rasa.shared.nlu.constants import (
 )
 from rasa.shared.nlu.training_data.features import Features
 from rasa.shared.utils import common
+from rasa.shared.utils.io import raise_deprecation_warning
 from rasa.utils import train_utils
 from rasa.utils.tensorflow import layers
 from rasa.utils.tensorflow.constants import (
@@ -300,6 +301,10 @@ class UnexpecTEDIntentPolicy(TEDPolicy):
         label_quantiles: Optional[Dict[int, List[float]]] = None,
     ):
         """Declares instance variables with default values."""
+        raise_deprecation_warning(
+            "UnexpecTEDIntentPolicy is deprecated and "
+            "will be removed in a future version."
+        )
         # Set all invalid / non configurable parameters
         config[ENTITY_RECOGNITION] = False
         config[BILOU_FLAG] = False
@@ -624,6 +629,7 @@ class UnexpecTEDIntentPolicy(TEDPolicy):
         query_intent = (
             last_user_uttered_event.intent_name
             if last_user_uttered_event is not None
+            and isinstance(last_user_uttered_event, UserUttered)
             else ""
         )
         is_unlikely_intent = self._check_unlikely_intent(