rasa-pro 3.14.1__tar.gz → 3.15.0.dev20251027__tar.gz

{rasa_pro-3.14.1 → rasa_pro-3.15.0.dev20251027}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: rasa-pro
-Version: 3.14.1
+Version: 3.15.0.dev20251027
 Summary: State-of-the-art open-core Conversational AI framework for Enterprises that natively leverages generative AI for effortless assistant development.
 Keywords: nlp,machine-learning,machine-learning-library,bot,bots,botkit,rasa conversational-agents,conversational-ai,chatbot,chatbot-framework,bot-framework
 Author: Rasa Technologies GmbH
@@ -21,6 +21,7 @@ Provides-Extra: full
 Provides-Extra: gh-release-notes
 Provides-Extra: jieba
 Provides-Extra: metal
+Provides-Extra: monitoring
 Provides-Extra: nlu
 Provides-Extra: pii
 Provides-Extra: spacy
@@ -72,6 +73,7 @@ Requires-Dist: keras (>=3.11.0)
 Requires-Dist: langchain (>=0.3.27,<0.4.0)
 Requires-Dist: langchain-community (>=0.3.29,<0.4.0)
 Requires-Dist: langcodes (>=3.5.0,<4.0.0)
+Requires-Dist: langfuse (>=3.6.0,<3.7.0) ; extra == "full" or extra == "monitoring"
 Requires-Dist: litellm (>=1.69.0,<1.70.0)
 Requires-Dist: matplotlib (>=3.9.4,<3.10.0)
 Requires-Dist: mattermostwrapper (>=2.2,<2.3) ; extra == "full" or extra == "channels"
@@ -108,7 +110,7 @@ Requires-Dist: pyyaml (>=6.0.2,<6.1.0)
 Requires-Dist: qdrant-client (>=1.9.1,<1.10.0)
 Requires-Dist: questionary (>=2.1.1,<2.2.0)
 Requires-Dist: randomname (>=0.2.1,<0.3.0)
-Requires-Dist: rasa-sdk (==3.14.0)
+Requires-Dist: rasa-sdk (==3.15.0.dev1)
 Requires-Dist: redis (>=4.6.0,<6.0)
 Requires-Dist: regex (>=2024.7.24,<2024.8.0)
 Requires-Dist: requests (>=2.32.5,<2.33.0)

{rasa_pro-3.14.1 → rasa_pro-3.15.0.dev20251027}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "rasa-pro"
-version = "3.14.1"
+version = "3.15.0.dev20251027"
 description = "State-of-the-art open-core Conversational AI framework for Enterprises that natively leverages generative AI for effortless assistant development."
 authors = [ "Rasa Technologies GmbH <hi@rasa.com>",]
 maintainers = [ "Tom Bocklisch <tom@rasa.com>",]
@@ -134,6 +134,10 @@ line-length = 88
 target-version = "py39"
 exclude = [ "eggs", ".git", ".pytest_cache", "build", "dist",]
 
+# --------------------------------------------------------------------------------------
+# MAIN DEPENDENCIES
+# --------------------------------------------------------------------------------------
+
 [tool.poetry.dependencies]
 python = ">=3.10.0,<3.14"
 boto3 = "~1.40.21"
@@ -236,7 +240,9 @@ pep440-version-utils = "~1.2.0"
 werkzeug = "^3.1.3"
 keras = ">=3.11.0"
 
-# non-optional dependencies with additional requirements
+# --------------------------------------------------------------------------------------
+# NON-OPTIONAL DEPENDENCIES WITH ADDITIONAL REQUIREMENTS
+# --------------------------------------------------------------------------------------
 
 [[tool.poetry.dependencies.scipy]]
 version = "~1.13.1"
@@ -247,7 +253,7 @@ version = "~1.14.0"
 markers = "python_version >= '3.12'"
 
 [[tool.poetry.dependencies.rasa-sdk]]
-version = "3.14.0"  # upgraded to use updated protobuf required for python 3.12, depends on protobuf (>=5.29.5,<5.30.0)
+version = "3.15.0.dev1"  # upgraded to use updated protobuf required for python 3.12, depends on protobuf (>=5.29.5,<5.30.0)
 allow-prereleases = true
 
 [tool.poetry.dependencies.PyJWT]
@@ -262,7 +268,9 @@ markers = "sys_platform == 'win32'"
 version = "~0.2.2"
 markers = "python_version >= '3.13'"  # audioop deprecated for Python 3.13+
 
-# optional dependencies
+# --------------------------------------------------------------------------------------
+# OPTIONAL DEPENDENCIES
+# --------------------------------------------------------------------------------------
 
 [tool.poetry.dependencies.gliner]
 version = "~0.2.20"
@@ -280,7 +288,9 @@ optional = true
 version = "~3.2.0"
 optional = true
 
-# optional dependencies required for channels
+# --------------------------------------------------------------------------------------
+# OPTIONAL DEPENDENCIES REQUIRED FOR CHANNELS
+# --------------------------------------------------------------------------------------
 
 [tool.poetry.dependencies.fbmessenger]
 version = "~6.0.0"
@@ -314,7 +324,17 @@ optional = true
 version = "^0.5.1"
 optional = true
 
-# optional dependencies required for nlu components
+# --------------------------------------------------------------------------------------
+# OPTIONAL DEPENDENCIES REQUIRED FOR MONITORING
+# --------------------------------------------------------------------------------------
+
+[tool.poetry.dependencies.langfuse]
+version = "~3.6.0"
+optional = true
+
+# --------------------------------------------------------------------------------------
+# OPTIONAL DEPENDENCIES REQUIRED FOR NLU COMPONENTS
+# --------------------------------------------------------------------------------------
 
 [tool.poetry.dependencies.sentencepiece]
 version = "~0.1.99"
@@ -345,7 +365,9 @@ optional = true
 version = "~0.5.0"
 optional = true
 
-# TensorFlow-related dependencies, optional
+# --------------------------------------------------------------------------------------
+# OPTIONAL DEPENDENCIES FOR TENSORFLOW-RELATED PACKAGES
+# --------------------------------------------------------------------------------------
 
 [tool.poetry.dependencies.tensorflow]
 version = "^2.19.0" # compatible with protobuf <6.0.0dev
@@ -388,13 +410,16 @@ version = "^2.15.0"
 markers = "python_version < '3.12'"
 optional = true
 
-# extras
+# --------------------------------------------------------------------------------------
+# EXTRAS
+# --------------------------------------------------------------------------------------
+
 [tool.poetry.extras]
 spacy = [ "spacy",]
 jieba = [ "jieba",]
 transformers = [ "transformers", "sentencepiece",]
 # full encompasses spacy, jieba, transformers, sentencepiece, gitpython (previous dependencies from extra groups) +
-# nlu and channel group dependencies
+# nlu, channels group and monitoring dependencies
 full = [
     "spacy",
     "jieba",
@@ -421,6 +446,7 @@ full = [
     "aiogram",
     "slack-sdk",
     "cvg-python-sdk",
+    "langfuse",
 ]
 gh-release-notes = [ "github3.py",]
 metal = [ "tensorflow-metal",]
@@ -452,6 +478,10 @@ nlu = [
      "slack-sdk",
      "cvg-python-sdk",
  ]
+# monitoring encompasses all dependencies required for monitoring
+monitoring = [
+    "langfuse",
+]
 
 [tool.poetry.scripts]
 rasa = "rasa.__main__:main"
@@ -507,6 +537,9 @@ convention = "google"
 
 
 
+
+
+
 [tool.poetry.group.dev.dependencies]
 ruff = ">=0.3.5,<0.4.0"
 docker = "~7.1.0"

{rasa_pro-3.14.1 → rasa_pro-3.15.0.dev20251027}/rasa/builder/config.py

@@ -13,6 +13,10 @@ OPENAI_VECTOR_STORE_ID = os.getenv(
 )
 OPENAI_MAX_VECTOR_RESULTS = int(os.getenv("OPENAI_MAX_VECTOR_RESULTS", "10"))
 OPENAI_TIMEOUT = int(os.getenv("OPENAI_TIMEOUT", "30"))
+# OpenAI Token Pricing Configuration (per 1,000 tokens)
+COPILOT_INPUT_TOKEN_PRICE = float(os.getenv("COPILOT_INPUT_TOKEN_PRICE", "0.002"))
+COPILOT_OUTPUT_TOKEN_PRICE = float(os.getenv("COPILOT_OUTPUT_TOKEN_PRICE", "0.0005"))
+COPILOT_CACHED_TOKEN_PRICE = float(os.getenv("COPILOT_CACHED_TOKEN_PRICE", "0.002"))
 
 # Server Configuration
 BUILDER_SERVER_HOST = os.getenv("SERVER_HOST", "0.0.0.0")

{rasa_pro-3.14.1 → rasa_pro-3.15.0.dev20251027}/rasa/builder/copilot/copilot.py

@@ -42,6 +42,7 @@ from rasa.builder.exceptions import (
     DocumentRetrievalError,
 )
 from rasa.builder.shared.tracker_context import TrackerContext
+from rasa.builder.telemetry.copilot_langfuse_telemetry import CopilotLangfuseTelemetry
 from rasa.shared.constants import PACKAGE_NAME
 
 structlogger = structlog.get_logger()
@@ -72,7 +73,11 @@ class Copilot:
         )
 
         # The final stream chunk includes usage statistics.
-        self.usage_statistics = UsageStatistics()
+        self.usage_statistics = UsageStatistics(
+            input_token_price=config.COPILOT_INPUT_TOKEN_PRICE,
+            output_token_price=config.COPILOT_OUTPUT_TOKEN_PRICE,
+            cached_token_price=config.COPILOT_CACHED_TOKEN_PRICE,
+        )
 
     @asynccontextmanager
     async def _get_client(self) -> AsyncGenerator[openai.AsyncOpenAI, None]:
@@ -94,6 +99,16 @@ class Copilot:
                     error=str(exc),
                 )
 
+    @property
+    def llm_config(self) -> Dict[str, Any]:
+        """The LLM config used to generate the response."""
+        return {
+            "model": config.OPENAI_MODEL,
+            "temperature": config.OPENAI_TEMPERATURE,
+            "stream": True,
+            "stream_options": {"include_usage": True},
+        }
+
     async def search_rasa_documentation(
         self,
         context: CopilotContext,
@@ -108,7 +123,9 @@ class Copilot:
         """
         try:
             query = self._create_documentation_search_query(context)
-            return await self._inkeep_document_retrieval.retrieve_documents(query)
+            documents = await self._inkeep_document_retrieval.retrieve_documents(query)
+            # TODO: Log documentation retrieval to Langfuse
+            return documents
         except DocumentRetrievalError as e:
             structlogger.error(
                 "copilot.search_rasa_documentation.error",
@@ -145,11 +162,12 @@ class Copilot:
             Exception: If an unexpected error occurs.
         """
         relevant_documents = await self.search_rasa_documentation(context)
-        messages = await self._build_messages(context, relevant_documents)
         tracker_event_attachments = self._extract_tracker_event_attachments(
             context.copilot_chat_history[-1]
         )
+        messages = await self._build_messages(context, relevant_documents)
 
+        # TODO: Delete this after Langfuse is implemented
         support_evidence = CopilotGenerationContext(
             relevant_documents=relevant_documents,
             system_message=messages[0],
@@ -163,6 +181,7 @@ class Copilot:
             support_evidence,
         )
 
+    @CopilotLangfuseTelemetry.trace_copilot_streaming_generation
     async def _stream_response(
         self, messages: List[Dict[str, Any]]
     ) -> AsyncGenerator[str, None]:
@@ -172,13 +191,10 @@ class Copilot:
         try:
             async with self._get_client() as client:
                 stream = await client.chat.completions.create(
-                    model=config.OPENAI_MODEL,
-                    messages=messages,  # type: ignore
-                    temperature=config.OPENAI_TEMPERATURE,
-                    stream=True,
-                    stream_options={"include_usage": True},
+                    messages=messages,
+                    **self.llm_config,
                 )
-                async for chunk in stream:
+                async for chunk in stream:  # type: ignore[attr-defined]
                     # The final chunk, which contains the usage statistics,
                     # arrives with an empty `choices` list.
                     if not chunk.choices:
@@ -189,6 +205,7 @@ class Copilot:
                     delta = chunk.choices[0].delta
                     if delta and delta.content:
                         yield delta.content
+
         except openai.OpenAIError as e:
             structlogger.exception("copilot.stream_response.api_error", error=str(e))
             raise CopilotStreamError(
@@ -559,4 +576,6 @@ class Copilot:
         """Extract the tracker event attachments from the message."""
         if not isinstance(message, UserChatMessage):
             return []
+        # TODO: Log tracker event attachments to Langfuse only in the case of the
+        #       User chat message.
         return message.get_content_blocks_by_type(EventContent)

{rasa_pro-3.14.1 → rasa_pro-3.15.0.dev20251027}/rasa/builder/copilot/models.py

@@ -3,6 +3,7 @@ from enum import Enum
 from typing import Any, Dict, List, Literal, Optional, Type, TypeVar, Union
 
 import structlog
+from openai.types.chat import ChatCompletion
 from openai.types.chat.chat_completion_chunk import ChatCompletionChunk
 from pydantic import (
     BaseModel,
@@ -343,6 +344,55 @@ ChatMessage = Union[
 ]
 
 
+def create_chat_message_from_dict(message_data: Dict[str, Any]) -> ChatMessage:
+    """Parse a single chat message dictionary into a ChatMessage object.
+
+    This utility function manually parses a chat message dictionary into the
+    appropriate ChatMessage type based on its role field.
+
+    Args:
+        message_data: Dictionary containing chat message data
+
+    Returns:
+        Parsed ChatMessage object
+
+    Raises:
+        ValueError: If an unknown role is encountered
+
+    Example:
+        >>> message_data = {
+        ...     "role": "user",
+        ...     "content": [{"type": "text", "text": "Hello"}]
+        ... }
+        >>> message = parse_chat_message_from_dict(message_data)
+        >>> isinstance(message, UserChatMessage)
+        True
+        >>> message.role
+        'user'
+    """
+    available_roles = [ROLE_USER, ROLE_COPILOT, ROLE_COPILOT_INTERNAL]
+    role = message_data.get("role")
+
+    if role == ROLE_USER:
+        return UserChatMessage(**message_data)
+    elif role == ROLE_COPILOT:
+        return CopilotChatMessage(**message_data)
+    elif role == ROLE_COPILOT_INTERNAL:
+        return InternalCopilotRequestChatMessage(**message_data)
+    else:
+        message = (
+            f"Unknown role '{role}' in chat message. "
+            f"Available roles are: {', '.join(available_roles)}."
+        )
+        structlogger.error(
+            "models.create_chat_message_from_dict.unknown_role",
+            event_info=message,
+            role=role,
+            available_roles=available_roles,
+        )
+        raise ValueError(message)
+
+
 class CopilotContext(BaseModel):
     """Model containing the context used by the copilot to generate a response."""
 
@@ -390,37 +440,40 @@ class CopilotRequest(BaseModel):
 
     @field_validator("copilot_chat_history", mode="before")
     @classmethod
-    def parse_chat_history(cls, v: List[Dict[str, Any]]) -> List[ChatMessage]:
+    def parse_chat_history(
+        cls, v: Union[List[Dict[str, Any]], List[ChatMessage]]
+    ) -> List[ChatMessage]:
         """Manually parse chat history messages based on role field."""
+        # If already parsed ChatMessage objects, return them as-is
+        if (
+            v
+            and isinstance(v, list)
+            and all(isinstance(item, ChatMessage) for item in v)
+        ):
+            return v  # type: ignore[return-value]
+
+        # Check for mixed types (some ChatMessage, some not)
+        if (
+            v
+            and isinstance(v, list)
+            and any(isinstance(item, ChatMessage) for item in v)
+        ):
+            message = (
+                "Mixed types in copilot_chat_history: cannot mix ChatMessage objects"
+                "with other types."
+            )
+            structlog.get_logger().error(
+                "copilot_request.parse_chat_history.mixed_types",
+                event_info=message,
+                chat_history_types=[type(item) for item in v],
+            )
+            raise ValueError(message)
+
+        # Otherwise, parse from dictionaries
         parsed_messages: List[ChatMessage] = []
-        available_roles = [ROLE_USER, ROLE_COPILOT, ROLE_COPILOT_INTERNAL]
         for message_data in v:
-            role = message_data.get("role")
-
-            if role == ROLE_USER:
-                parsed_messages.append(UserChatMessage(**message_data))
-
-            elif role == ROLE_COPILOT:
-                parsed_messages.append(CopilotChatMessage(**message_data))
-
-            elif role == ROLE_COPILOT_INTERNAL:
-                parsed_messages.append(
-                    InternalCopilotRequestChatMessage(**message_data)
-                )
-
-            else:
-                message = (
-                    f"Unknown role '{role}' in chat message. "
-                    f"Available roles are: {', '.join(available_roles)}."
-                )
-                structlogger.error(
-                    "copilot_request.parse_chat_history.unknown_role",
-                    event_info=message,
-                    role=role,
-                    available_roles=available_roles,
-                )
-                raise ValueError(message)
-
+            chat_message = create_chat_message_from_dict(message_data)
+            parsed_messages.append(chat_message)
         return parsed_messages
 
     @property
@@ -612,16 +665,171 @@ class TrainingErrorLog(CopilotOutput):
 
 
 class UsageStatistics(BaseModel):
-    prompt_tokens: Optional[int] = None
-    completion_tokens: Optional[int] = None
-    total_tokens: Optional[int] = None
-    model: Optional[str] = None
+    """Usage statistics for a copilot generation."""
+
+    # Token usage statistics
+    prompt_tokens: Optional[int] = Field(
+        default=None,
+        description=(
+            "Total number of prompt tokens used to generate completion. "
+            "Should include cached prompt tokens."
+        ),
+    )
+    completion_tokens: Optional[int] = Field(
+        default=None,
+        description="Number of generated tokens.",
+    )
+    total_tokens: Optional[int] = Field(
+        default=None,
+        description="Total number of tokens used (input + output).",
+    )
+    cached_prompt_tokens: Optional[int] = Field(
+        default=None,
+        description="Number of cached prompt tokens.",
+    )
+    model: Optional[str] = Field(
+        default=None,
+        description="The model used to generate the response.",
+    )
+
+    # Token prices
+    input_token_price: float = Field(
+        default=0.0,
+        description="Price per 1K input tokens in dollars.",
+    )
+    output_token_price: float = Field(
+        default=0.0,
+        description="Price per 1K output tokens in dollars.",
+    )
+    cached_token_price: float = Field(
+        default=0.0,
+        description="Price per 1K cached tokens in dollars.",
+    )
+
+    @property
+    def non_cached_prompt_tokens(self) -> Optional[int]:
+        """Get the non-cached prompt tokens."""
+        if self.cached_prompt_tokens is not None and self.prompt_tokens is not None:
+            return self.prompt_tokens - self.cached_prompt_tokens
+        return self.prompt_tokens
+
+    @property
+    def non_cached_cost(self) -> Optional[float]:
+        """Calculate the non-cached token cost based on configured pricing."""
+        if self.non_cached_prompt_tokens is None:
+            return None
+        if self.non_cached_prompt_tokens == 0:
+            return 0.0
+
+        return (self.non_cached_prompt_tokens / 1000.0) * self.input_token_price
+
+    @property
+    def cached_cost(self) -> Optional[float]:
+        """Calculate the cached token cost based on configured pricing."""
+        if self.cached_prompt_tokens is None:
+            return None
+        if self.cached_prompt_tokens == 0:
+            return 0.0
+
+        return (self.cached_prompt_tokens / 1000.0) * self.cached_token_price
+
+    @property
+    def input_cost(self) -> Optional[float]:
+        """Calculate the input token cost based on configured pricing.
+
+        The calculation takes into account the cached prompt tokens (if available) too.
+        """
+        # If both non-cached and cached costs are None, there's no input cost
+        if self.non_cached_cost is None and self.cached_cost is None:
+            return None
+
+        # If only non-cached cost is available, return it
+        if self.non_cached_cost is not None and self.cached_cost is None:
+            return self.non_cached_cost
+
+        # If only cached cost is available, return it
+        if self.non_cached_cost is None and self.cached_cost is not None:
+            return self.cached_cost
+
+        # If both are available, return the sum
+        return self.non_cached_cost + self.cached_cost  # type: ignore[operator]
+
+    @property
+    def output_cost(self) -> Optional[float]:
+        """Calculate the output token cost based on configured pricing."""
+        if self.completion_tokens is None:
+            return None
+        if self.completion_tokens == 0:
+            return 0.0
+
+        return (self.completion_tokens / 1000.0) * self.output_token_price
+
+    @property
+    def total_cost(self) -> Optional[float]:
+        """Calculate the total cost based on configured pricing.
+
+        Returns:
+            Total cost in dollars, or None if insufficient data.
+        """
+        if self.input_cost is None or self.output_cost is None:
+            return None
+
+        return self.input_cost + self.output_cost
+
+    def update_token_prices(
+        self,
+        input_token_price: float,
+        output_token_price: float,
+        cached_token_price: float,
+    ) -> None:
+        """Update token prices with provided values.
+
+        Args:
+            input_token_price: Price per 1K input tokens in dollars.
+            output_token_price: Price per 1K output tokens in dollars.
+            cached_token_price: Price per 1K cached tokens in dollars.
+        """
+        self.input_token_price = input_token_price
+        self.output_token_price = output_token_price
+        self.cached_token_price = cached_token_price
+
+    @classmethod
+    def from_chat_completion_response(
+        cls,
+        response: ChatCompletion,
+        input_token_price: float = 0.0,
+        output_token_price: float = 0.0,
+        cached_token_price: float = 0.0,
+    ) -> Optional["UsageStatistics"]:
+        """Create a UsageStatistics object from a ChatCompletionChunk."""
+        if not (usage := getattr(response, "usage", None)):
+            return None
+
+        usage_statistics = cls(
+            input_token_price=input_token_price,
+            output_token_price=output_token_price,
+            cached_token_price=cached_token_price,
+        )
+
+        usage_statistics.prompt_tokens = usage.prompt_tokens
+        usage_statistics.completion_tokens = usage.completion_tokens
+        usage_statistics.total_tokens = usage.total_tokens
+        usage_statistics.model = getattr(response, "model", None)
+
+        # Extract cached tokens if available
+        if hasattr(usage, "prompt_tokens_details") and usage.prompt_tokens_details:
+            usage_statistics.cached_prompt_tokens = getattr(
+                usage.prompt_tokens_details, "cached_tokens", None
+            )
+
+        return usage_statistics
 
     def reset(self) -> None:
         """Reset usage statistics to their default values."""
         self.prompt_tokens = None
         self.completion_tokens = None
         self.total_tokens = None
+        self.cached_prompt_tokens = None
         self.model = None
 
     def update_from_stream_chunk(self, chunk: ChatCompletionChunk) -> None:
@@ -630,14 +838,25 @@ class UsageStatistics(BaseModel):
         Args:
             chunk: The OpenAI stream chunk containing usage statistics.
         """
+        # Reset the usage statistics to their default values
+        self.reset()
+
+        # If the chunk has no usage statistics, return
         if not (usage := getattr(chunk, "usage", None)):
             return
 
+        # Update the usage statistics with the values from the chunk
         self.prompt_tokens = usage.prompt_tokens
         self.completion_tokens = usage.completion_tokens
         self.total_tokens = usage.total_tokens
         self.model = getattr(chunk, "model", None)
 
+        # Extract cached tokens if available
+        if hasattr(usage, "prompt_tokens_details") and usage.prompt_tokens_details:
+            self.cached_prompt_tokens = getattr(
+                usage.prompt_tokens_details, "cached_tokens", None
+            )
+
 
 class SigningContext(BaseModel):
     secret: Optional[str] = Field(None)

{rasa_pro-3.14.1 → rasa_pro-3.15.0.dev20251027}/rasa/builder/document_retrieval/inkeep_document_retrieval.py

@@ -17,6 +17,7 @@ from rasa.builder.document_retrieval.constants import (
 )
 from rasa.builder.document_retrieval.models import Document
 from rasa.builder.exceptions import DocumentRetrievalError
+from rasa.builder.telemetry.copilot_langfuse_telemetry import CopilotLangfuseTelemetry
 from rasa.shared.utils.io import read_json_file
 
 structlogger = structlog.get_logger()
@@ -88,6 +89,7 @@ class InKeepDocumentRetrieval:
             )
             raise e
 
+    @CopilotLangfuseTelemetry.trace_document_retrieval_generation
     async def _call_inkeep_rag_api(
         self, query: str, temperature: float, timeout: float
     ) -> ChatCompletion:

{rasa_pro-3.14.1 → rasa_pro-3.15.0.dev20251027}/rasa/builder/download.py

@@ -27,7 +27,7 @@ def _get_pyproject_toml_content(project_id: str) -> str:
         version = "0.1.0"
         description = "Add your description for your Rasa bot here"
         readme = "README.md"
-        dependencies = ["rasa-pro>=3.13"]
+        dependencies = ["rasa-pro>=3.14"]
         requires-python = ">={sys.version_info.major}.{sys.version_info.minor}"
         """
     )

rasa_pro-3.15.0.dev20251027/rasa/builder/evaluator/constants.py

@@ -0,0 +1,15 @@
+"""Constants for the evaluator module."""
+
+from pathlib import Path
+
+# Base directory for the rasa package
+BASE_DIR = Path(__file__).parent.parent.parent
+
+# Response classification evaluation results directory
+RESPONSE_CLASSIFICATION_EVALUATION_RESULTS_DIR = (
+    BASE_DIR / "builder" / "evaluator" / "results"
+)
+# Default output filename
+DEFAULT_RESPONSE_CLASSIFICATION_EVALUATION_TEXT_OUTPUT_FILENAME = "run_results.txt"
+# Default YAML output filename
+RESPONSE_CLASSIFICATION_EVALUATION_YAML_OUTPUT_FILENAME = "run_results.yaml"