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

rasa/shared/core/slots.py

@@ -68,9 +68,9 @@ class SlotRejection:
 
 
 class SlotValidation(BaseModel):
-    rejections: List[SlotRejection] = Field(alias=REJECTIONS)
+    rejections: List[SlotRejection] = Field(alias=REJECTIONS)  # type: ignore[literal-required]
     """how the slot value is validated using predicate evaluation."""
-    refill_utter: str = Field(alias=REFILL_UTTER)
+    refill_utter: str = Field(alias=REFILL_UTTER)  # type: ignore[literal-required]
     """The utterance that the assistant uses to ask for the slot."""
 
     @staticmethod
@@ -273,10 +273,14 @@ class Slot(ABC):
         try:
             return rasa.shared.utils.common.class_from_module_path(type_name)
         except (ImportError, AttributeError):
+            known_types = [
+                cls.type_name for cls in rasa.shared.utils.common.all_subclasses(Slot)
+            ]
             raise InvalidSlotTypeException(
                 f"Failed to find slot type, '{type_name}' is neither a known type nor "
                 f"user-defined. If you are creating your own slot type, make "
                 f"sure its module path is correct. "
+                f"Known types: {', '.join(known_types)} "
                 f"You can find all build in types at {DOCS_URL_SLOTS}"
             )
 

rasa/shared/core/trackers.py

@@ -849,7 +849,7 @@ class DialogueStateTracker:
         action_names_to_exclude: Optional[List[Text]] = None,
         skip: int = 0,
         event_verbosity: EventVerbosity = EventVerbosity.APPLIED,
-    ) -> Optional["EventTypeAlias"]:
+    ) -> Optional[Event]:
         """Gets the last event of a given type which was actually applied.
 
         Args:
@@ -889,9 +889,12 @@ class DialogueStateTracker:
         Returns:
             `True` if last executed action had name `name`, otherwise `False`.
         """
-        last: Optional[ActionExecuted] = self.get_last_event_for(
+        last_event = self.get_last_event_for(
             ActionExecuted, action_names_to_exclude=[ACTION_LISTEN_NAME], skip=skip
         )
+        last: Optional[ActionExecuted] = (
+            last_event if isinstance(last_event, ActionExecuted) else None
+        )
         return last is not None and last.action_name == name
 
     ###

rasa/shared/core/training_data/story_reader/story_reader.py

@@ -126,4 +126,4 @@ class StoryParseError(RasaCoreException, ValueError):
 
     def __init__(self, message: Text) -> None:
         self.message = message
-        super(StoryParseError, self).__init__()
+        super(StoryParseError, self).__init__(message)

rasa/shared/exceptions.py

@@ -16,6 +16,17 @@ class RasaException(Exception):
     to the users, but will be ignored in telemetry.
     """
 
+    def __init__(self, message: str, suppress_stack_trace: bool = False, **kwargs: Any):
+        """Initialize the exception.
+
+        Args:
+            message: The error message.
+            suppress_stack_trace: If True, the stack trace will be suppressed in logs.
+            **kwargs: Additional keyword arguments (e.g., cause for exception chaining).
+        """
+        Exception.__init__(self, message)
+        self.suppress_stack_trace = suppress_stack_trace
+
 
 class RasaCoreException(RasaException):
     """Basic exception for errors raised by Rasa Core."""
@@ -113,6 +124,17 @@ class SchemaValidationError(RasaException, jsonschema.ValidationError):
 class InvalidEntityFormatException(RasaException, json.JSONDecodeError):
     """Raised if the format of an entity is invalid."""
 
+    def __init__(self, msg: str, doc: str = "", pos: int = 0):
+        """Initialize the exception.
+
+        Args:
+            msg: The error message.
+            doc: The document that caused the error.
+            pos: The position in the document where the error occurred.
+        """
+        RasaException.__init__(self, msg)
+        json.JSONDecodeError.__init__(self, msg, doc, pos)
+
     @classmethod
     def create_from(
         cls, other: json.JSONDecodeError, msg: Text
@@ -130,8 +152,7 @@ class ConnectionException(RasaException):
 
 
 class ProviderClientAPIException(RasaException):
-    """Raised for errors that occur during API interactions
-    with LLM / embedding providers.
+    """For errors during API interactions with LLM / embedding providers.
 
     Attributes:
         original_exception (Exception): The original exception that was
@@ -163,9 +184,25 @@ class ProviderClientAPIException(RasaException):
         return s
 
 
+class LLMToolResponseDecodeError(ProviderClientAPIException):
+    """Raised when a JSON decoding error occurs in LLM tool response."""
+
+
 class ProviderClientValidationError(RasaException):
     """Raised for errors that occur during validation of the API client."""
 
 
 class FinetuningDataPreparationException(RasaException):
     """Raised when there is an error in data preparation for fine-tuning."""
+
+
+class AgentInitializationException(RasaException):
+    """Raised when there is an error during the initialization of an agent."""
+
+
+class AgentAuthInitializationException(RasaException):
+    """Raised when there is an error during the initialization of agent auth client."""
+
+
+class AuthenticationError(RasaException):
+    """Raised when there is an authentication error."""

rasa/shared/importers/importer.py

@@ -207,6 +207,12 @@ class TrainingDataImporter(ABC):
                 )
             ]
 
+        return TrainingDataImporter.wrap_in_builtins(importers)
+
+    @staticmethod
+    def wrap_in_builtins(
+        importers: List["TrainingDataImporter"],
+    ) -> "TrainingDataImporter":
         return LanguageImporter(
             E2EImporter(
                 FlowSyncImporter(ResponsesSyncImporter(CombinedDataImporter(importers)))

rasa/shared/importers/rasa.py

@@ -74,7 +74,7 @@ class RasaFileImporter(TrainingDataImporter):
     @cached_method
     def get_flows(self) -> FlowsList:
         """Retrieves training stories / rules (see parent class for full docstring)."""
-        return utils.flows_from_paths(self._flow_files)
+        return utils.flows_from_paths(self._flow_files, self.get_domain())
 
     @cached_method
     def get_conversation_tests(self) -> StoryGraph:

rasa/shared/importers/utils.py

@@ -1,9 +1,37 @@
-from typing import Iterable, List, Optional, Text
+from typing import Any, Dict, Iterable, List, Optional, Text
+
+from pydantic import BaseModel, Field
 
 from rasa.shared.core.domain import Domain
 from rasa.shared.core.flows import FlowsList
+from rasa.shared.core.flows.yaml_flows_io import KEY_FLOWS, get_flows_as_json
 from rasa.shared.core.training_data.structures import StoryGraph
+from rasa.shared.importers.importer import TrainingDataImporter
+from rasa.shared.nlu.training_data.formats.rasa_yaml import RasaYAMLWriter
 from rasa.shared.nlu.training_data.training_data import TrainingData
+from rasa.utils.json_utils import extract_values
+
+
+class CALMUserData(BaseModel):
+    """All pieces that will be uploaded to Rasa Studio."""
+
+    flows: Dict[str, Any] = Field(default_factory=dict)
+    domain: Dict[str, Any] = Field(default_factory=dict)
+    config: Dict[str, Any] = Field(default_factory=dict)
+    endpoints: Dict[str, Any] = Field(default_factory=dict)
+    nlu: Dict[str, Any] = Field(default_factory=dict)
+
+
+DOMAIN_KEYS = [
+    "version",
+    "actions",
+    "responses",
+    "slots",
+    "intents",
+    "entities",
+    "forms",
+    "session_config",
+]
 
 
 def training_data_from_paths(paths: Iterable[Text], language: Text) -> TrainingData:
@@ -23,8 +51,14 @@ def story_graph_from_paths(
     return StoryGraph(story_steps)
 
 
-def flows_from_paths(files: List[Text]) -> FlowsList:
-    """Returns the flows from paths."""
+def flows_from_paths(files: List[Text], domain: Optional[Domain] = None) -> FlowsList:
+    """Returns the flows from paths.
+
+    Args:
+        files: List of flow file paths to load.
+        domain: Optional domain for validation. If provided, exit_if conditions
+               will be validated against defined slots.
+    """
     from rasa.shared.core.flows.yaml_flows_io import YAMLFlowsReader
 
     flows = FlowsList(underlying_flows=[])
@@ -32,5 +66,53 @@ def flows_from_paths(files: List[Text]) -> FlowsList:
         flows = flows.merge(
             YAMLFlowsReader.read_from_file(file), ignore_duplicates=False
         )
-    flows.validate()
+    flows.validate(domain)
     return flows
+
+
+def extract_calm_import_parts_from_importer(
+    importer: TrainingDataImporter,
+    config: Optional[Dict[str, Any]] = None,
+    endpoints: Optional[Dict[str, Any]] = None,
+) -> CALMUserData:
+    """Extracts CALMUserData from a TrainingDataImporter.
+
+    Args:
+        importer: The training data importer
+        data_paths: The path(s) to the training data for flows
+        config: Optional config dict, if not provided will use importer.get_config()
+        endpoints: Optional endpoints dict, defaults to empty dict
+
+    Returns:
+        CALMUserData containing flows, domain, config, endpoints, and nlu data
+    """
+    # Extract config
+    if config is None:
+        config = importer.get_config()
+
+    # Extract domain
+    domain_from_files = importer.get_user_domain().as_dict()
+    domain = extract_values(domain_from_files, DOMAIN_KEYS)
+
+    # Extract flows
+    flows = importer.get_user_flows()
+    flows_dict = {KEY_FLOWS: get_flows_as_json(flows)}
+
+    # Extract NLU data
+    nlu_data = importer.get_nlu_data()
+    nlu_examples = nlu_data.filter_training_examples(
+        lambda ex: ex.get("intent") in nlu_data.intents
+    )
+    nlu_dict = RasaYAMLWriter().training_data_to_dict(nlu_examples)
+
+    # Use provided endpoints or default to empty dict
+    if endpoints is None:
+        endpoints = {}
+
+    return CALMUserData(
+        flows=flows_dict or {},
+        domain=domain or {},
+        config=config or {},
+        endpoints=endpoints or {},
+        nlu=nlu_dict or {},
+    )

rasa/shared/nlu/training_data/schemas/responses.yml

@@ -72,6 +72,9 @@ schema;responses:
               allowempty: True
           channel:
             type: "str"
+          allow_interruptions:
+            type: "bool"
+            required: False
           metadata:
             type: "any"
           condition:

rasa/shared/providers/llm/_base_litellm_client.py

@@ -21,7 +21,7 @@ from rasa.shared.providers._ssl_verification_utils import (
     ensure_ssl_certificates_for_litellm_non_openai_based_clients,
     ensure_ssl_certificates_for_litellm_openai_based_clients,
 )
-from rasa.shared.providers.llm.llm_response import LLMResponse, LLMUsage
+from rasa.shared.providers.llm.llm_response import LLMResponse, LLMToolCall, LLMUsage
 from rasa.shared.utils.io import resolve_environment_variables, suppress_logs
 
 structlogger = structlog.get_logger()
@@ -126,7 +126,9 @@ class _BaseLiteLLMClient:
             raise ProviderClientValidationError(event_info)
 
     @suppress_logs(log_level=logging.WARNING)
-    def completion(self, messages: Union[List[dict], List[str], str]) -> LLMResponse:
+    def completion(
+        self, messages: Union[List[dict], List[str], str], **kwargs: Any
+    ) -> LLMResponse:
         """Synchronously generate completions for given list of messages.
 
         Args:
@@ -138,6 +140,7 @@ class _BaseLiteLLMClient:
                 - a list of messages. Each message is a string and will be formatted
                     as a user message.
                 - a single message as a string which will be formatted as user message.
+            **kwargs: Additional parameters to pass to the completion call.
 
         Returns:
             List of message completions.
@@ -147,15 +150,19 @@ class _BaseLiteLLMClient:
         """
         try:
             formatted_messages = self._get_formatted_messages(messages)
-            arguments = resolve_environment_variables(self._completion_fn_args)
-            response = completion(messages=formatted_messages, **arguments)
+            arguments = cast(
+                Dict[str, Any], resolve_environment_variables(self._completion_fn_args)
+            )
+            response = completion(
+                messages=formatted_messages, **{**arguments, **kwargs}
+            )
             return self._format_response(response)
         except Exception as e:
-            raise ProviderClientAPIException(e)
+            raise ProviderClientAPIException(e) from e
 
     @suppress_logs(log_level=logging.WARNING)
     async def acompletion(
-        self, messages: Union[List[dict], List[str], str]
+        self, messages: Union[List[dict], List[str], str], **kwargs: Any
     ) -> LLMResponse:
         """Asynchronously generate completions for given list of messages.
 
@@ -168,6 +175,7 @@ class _BaseLiteLLMClient:
                 - a list of messages. Each message is a string and will be formatted
                     as a user message.
                 - a single message as a string which will be formatted as user message.
+            **kwargs: Additional parameters to pass to the completion call.
 
         Returns:
             List of message completions.
@@ -177,8 +185,12 @@ class _BaseLiteLLMClient:
         """
         try:
             formatted_messages = self._get_formatted_messages(messages)
-            arguments = resolve_environment_variables(self._completion_fn_args)
-            response = await acompletion(messages=formatted_messages, **arguments)
+            arguments = cast(
+                Dict[str, Any], resolve_environment_variables(self._completion_fn_args)
+            )
+            response = await acompletion(
+                messages=formatted_messages, **{**arguments, **kwargs}
+            )
             return self._format_response(response)
         except Exception as e:
             message = ""
@@ -197,7 +209,7 @@ class _BaseLiteLLMClient:
                     "In case you are getting OpenAI connection errors, such as missing "
                     "API key, your configuration is incorrect."
                 )
-            raise ProviderClientAPIException(e, message)
+            raise ProviderClientAPIException(e, message) from e
 
     def _get_formatted_messages(
         self, messages: Union[List[dict], List[str], str]
@@ -246,12 +258,32 @@ class _BaseLiteLLMClient:
                 else 0
             )
             formatted_response.usage = LLMUsage(prompt_tokens, completion_tokens)
+
+        # Extract tool calls from all choices
+        formatted_response.tool_calls = self._extract_tool_calls(response)
+
         structlogger.debug(
             "base_litellm_client.formatted_response",
             formatted_response=formatted_response.to_dict(),
         )
         return formatted_response
 
+    def _extract_tool_calls(self, response: Any) -> List[LLMToolCall]:
+        """Extract tool calls from response choices.
+
+        Args:
+            response: List of response choices from LiteLLM
+
+        Returns:
+            List of LLMToolCall objects, empty if no tool calls found
+        """
+        return [
+            LLMToolCall.from_litellm(tool_call)
+            for choice in response.choices
+            if choice.message.tool_calls
+            for tool_call in choice.message.tool_calls
+        ]
+
     def _format_text_completion_response(self, response: Any) -> LLMResponse:
         """Parses the LiteLLM text completion response to Rasa format."""
         formatted_response = LLMResponse(

rasa/shared/providers/llm/litellm_router_llm_client.py

@@ -122,7 +122,9 @@ class LiteLLMRouterLLMClient(_BaseLiteLLMRouterClient, _BaseLiteLLMClient):
             raise ProviderClientAPIException(e)
 
     @suppress_logs(log_level=logging.WARNING)
-    def completion(self, messages: Union[List[dict], List[str], str]) -> LLMResponse:
+    def completion(
+        self, messages: Union[List[dict], List[str], str], **kwargs: Any
+    ) -> LLMResponse:
         """
         Synchronously generate completions for given list of messages.
 
@@ -140,6 +142,7 @@ class LiteLLMRouterLLMClient(_BaseLiteLLMRouterClient, _BaseLiteLLMClient):
                 - a list of messages. Each message is a string and will be formatted
                     as a user message.
                 - a single message as a string which will be formatted as user message.
+            **kwargs: Additional parameters to pass to the completion call.
         Returns:
             List of message completions.
         Raises:
@@ -148,9 +151,9 @@ class LiteLLMRouterLLMClient(_BaseLiteLLMRouterClient, _BaseLiteLLMClient):
         if not self._use_chat_completions_endpoint:
             return self._text_completion(messages)
         try:
-            formatted_messages = self._format_messages(messages)
+            formatted_messages = self._get_formatted_messages(messages)
             response = self.router_client.completion(
-                messages=formatted_messages, **self._completion_fn_args
+                messages=formatted_messages, **{**self._completion_fn_args, **kwargs}
             )
             return self._format_response(response)
         except Exception as e:
@@ -158,7 +161,7 @@ class LiteLLMRouterLLMClient(_BaseLiteLLMRouterClient, _BaseLiteLLMClient):
 
     @suppress_logs(log_level=logging.WARNING)
     async def acompletion(
-        self, messages: Union[List[dict], List[str], str]
+        self, messages: Union[List[dict], List[str], str], **kwargs: Any
     ) -> LLMResponse:
         """
         Asynchronously generate completions for given list of messages.
@@ -177,6 +180,7 @@ class LiteLLMRouterLLMClient(_BaseLiteLLMRouterClient, _BaseLiteLLMClient):
                 - a list of messages. Each message is a string and will be formatted
                     as a user message.
                 - a single message as a string which will be formatted as user message.
+            **kwargs: Additional parameters to pass to the completion call.
         Returns:
             List of message completions.
         Raises:
@@ -185,9 +189,9 @@ class LiteLLMRouterLLMClient(_BaseLiteLLMRouterClient, _BaseLiteLLMClient):
         if not self._use_chat_completions_endpoint:
             return await self._atext_completion(messages)
         try:
-            formatted_messages = self._format_messages(messages)
+            formatted_messages = self._get_formatted_messages(messages)
             response = await self.router_client.acompletion(
-                messages=formatted_messages, **self._completion_fn_args
+                messages=formatted_messages, **{**self._completion_fn_args, **kwargs}
             )
             return self._format_response(response)
         except Exception as e:

rasa/shared/providers/llm/llm_client.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Dict, List, Protocol, Union, runtime_checkable
+from typing import Any, Dict, List, Protocol, Union, runtime_checkable
 
 from rasa.shared.providers.llm.llm_response import LLMResponse
 
@@ -32,7 +32,9 @@ class LLMClient(Protocol):
         """
         ...
 
-    def completion(self, messages: Union[List[dict], List[str], str]) -> LLMResponse:
+    def completion(
+        self, messages: Union[List[dict], List[str], str], **kwargs: Any
+    ) -> LLMResponse:
         """
         Synchronously generate completions for given list of messages.
 
@@ -48,13 +50,14 @@ class LLMClient(Protocol):
                 - a list of messages. Each message is a string and will be formatted
                     as a user message.
                 - a single message as a string which will be formatted as user message.
+            **kwargs: Additional parameters to pass to the completion call.
         Returns:
             LLMResponse
         """
         ...
 
     async def acompletion(
-        self, messages: Union[List[dict], List[str], str]
+        self, messages: Union[List[dict], List[str], str], **kwargs: Any
     ) -> LLMResponse:
         """
         Asynchronously generate completions for given list of messages.
@@ -71,6 +74,7 @@ class LLMClient(Protocol):
                 - a list of messages. Each message is a string and will be formatted
                     as a user message.
                 - a single message as a string which will be formatted as user message.
+            **kwargs: Additional parameters to pass to the completion call.
         Returns:
             LLMResponse
         """

rasa/shared/providers/llm/llm_response.py

@@ -1,9 +1,15 @@
 import functools
+import json
 import time
 from dataclasses import asdict, dataclass, field
 from typing import Any, Awaitable, Callable, Dict, List, Optional, Text, Union
 
 import structlog
+from litellm.utils import ChatCompletionMessageToolCall
+from pydantic import BaseModel
+
+from rasa.shared.constants import KEY_TOOL_CALLS
+from rasa.shared.exceptions import LLMToolResponseDecodeError
 
 structlogger = structlog.get_logger()
 
@@ -38,6 +44,53 @@ class LLMUsage:
         return asdict(self)
 
 
+class LLMToolCall(BaseModel):
+    """A class representing a response from an LLM tool call."""
+
+    id: str
+    """The ID of the tool call."""
+
+    tool_name: str
+    """The name of the tool that was called."""
+
+    tool_args: Dict[str, Any]
+    """The arguments passed to the tool call."""
+
+    type: str = "function"
+    """The type of the tool call."""
+
+    @classmethod
+    def from_dict(cls, data: Dict[Text, Any]) -> "LLMToolCall":
+        """Creates an LLMToolResponse from a dictionary."""
+        return cls(**data)
+
+    @classmethod
+    def from_litellm(cls, data: ChatCompletionMessageToolCall) -> "LLMToolCall":
+        """Creates an LLMToolResponse from a dictionary."""
+        try:
+            tool_args = json.loads(data.function.arguments)
+        except json.JSONDecodeError as e:
+            structlogger.error(
+                "llm_response.litellm_tool_call.invalid_arguments",
+                tool_name=data.function.name,
+                tool_call=data.function.arguments,
+            )
+            raise LLMToolResponseDecodeError(
+                original_exception=e,
+                message=(
+                    f"Invalid arguments for tool call - `{data.function.name}`: "
+                    f"`{data.function.arguments}`"
+                ),
+            ) from e
+
+        return cls(
+            id=data.id,
+            tool_name=data.function.name,
+            tool_args=tool_args,
+            type=data.type,
+        )
+
+
 @dataclass
 class LLMResponse:
     id: str
@@ -62,12 +115,22 @@ class LLMResponse:
     latency: Optional[float] = None
     """Optional field to store the latency of the LLM API call."""
 
+    tool_calls: Optional[List[LLMToolCall]] = None
+    """The list of tool calls the model generated for the input prompt."""
+
     @classmethod
     def from_dict(cls, data: Dict[Text, Any]) -> "LLMResponse":
         """Creates an LLMResponse from a dictionary."""
         usage_data = data.get("usage", {})
         usage_obj = LLMUsage.from_dict(usage_data) if usage_data else None
 
+        tool_calls_data = data.get(KEY_TOOL_CALLS, [])
+        tool_calls_obj = (
+            [LLMToolCall.from_dict(tool) for tool in tool_calls_data]
+            if tool_calls_data
+            else None
+        )
+
         return cls(
             id=data["id"],
             choices=data["choices"],
@@ -76,6 +139,7 @@ class LLMResponse:
             usage=usage_obj,
             additional_info=data.get("additional_info"),
             latency=data.get("latency"),
+            tool_calls=tool_calls_obj,
         )
 
     @classmethod
@@ -92,6 +156,8 @@ class LLMResponse:
         result = asdict(self)
         if self.usage:
             result["usage"] = self.usage.to_dict()
+        if self.tool_calls:
+            result[KEY_TOOL_CALLS] = [tool.model_dump() for tool in self.tool_calls]
         return result
 
 

rasa/shared/providers/llm/self_hosted_llm_client.py

@@ -237,7 +237,7 @@ class SelfHostedLLMClient(_BaseLiteLLMClient):
             raise ProviderClientAPIException(e)
 
     async def acompletion(
-        self, messages: Union[List[dict], List[str], str]
+        self, messages: Union[List[dict], List[str], str], **kwargs: Any
     ) -> LLMResponse:
         """Asynchronous completion of the model with the given messages.
 
@@ -255,15 +255,18 @@ class SelfHostedLLMClient(_BaseLiteLLMClient):
                 - a list of messages. Each message is a string and will be formatted
                     as a user message.
                 - a single message as a string which will be formatted as user message.
+            **kwargs: Additional parameters to pass to the completion call.
 
         Returns:
             The completion response.
         """
         if self._use_chat_completions_endpoint:
-            return await super().acompletion(messages)
+            return await super().acompletion(messages, **kwargs)
         return await self._atext_completion(messages)
 
-    def completion(self, messages: Union[List[dict], List[str], str]) -> LLMResponse:
+    def completion(
+        self, messages: Union[List[dict], List[str], str], **kwargs: Any
+    ) -> LLMResponse:
         """Completion of the model with the given messages.
 
         Method overrides the base class method to call the appropriate
@@ -273,12 +276,13 @@ class SelfHostedLLMClient(_BaseLiteLLMClient):
 
         Args:
             messages: The messages to be used for completion.
+            **kwargs: Additional parameters to pass to the completion call.
 
         Returns:
             The completion response.
         """
         if self._use_chat_completions_endpoint:
-            return super().completion(messages)
+            return super().completion(messages, **kwargs)
         return self._text_completion(messages)
 
     @staticmethod