rasa-pro 3.14.0rc4__py3-none-any.whl → 3.15.0a1__py3-none-any.whl

rasa/agents/agent_manager.py

@@ -15,7 +15,7 @@ structlogger = structlog.get_logger()
 
 
 class AgentManager(metaclass=Singleton):
-    """High-level agent management with protocol abstraction"""
+    """High-level agent management with protocol abstraction."""
 
     agents: ClassVar[Dict[AgentIdentifier, AgentProtocol]] = {}
 
@@ -66,9 +66,11 @@ class AgentManager(metaclass=Singleton):
     async def connect_agent(
         self, agent_name: str, protocol_type: ProtocolType, config: AgentConfig
     ) -> None:
-        """Connect to agent using specified protocol, load the default resources
-        and persist the agent to the manager in a ready-to-use state so that
-        it can be used immediately to send messages to the agent.
+        """Connect to agent using specified protocol.
+
+        Also, load the default resources and persist the agent to the manager
+        in a ready-to-use state so that it can be used immediately
+        to send messages to the agent.
 
         Args:
             agent_name: The name of the agent.
@@ -109,7 +111,7 @@ class AgentManager(metaclass=Singleton):
                 agent_id=str(agent_identifier),
                 event_info=event_info,
             )
-            raise AgentInitializationException(e) from e
+            raise AgentInitializationException(e, suppress_stack_trace=True) from e
 
     async def run_agent(
         self, agent_name: str, protocol_type: ProtocolType, context: AgentInput

rasa/agents/protocol/a2a/a2a_agent.py

@@ -65,7 +65,7 @@ structlogger = structlog.get_logger()
 
 
 class A2AAgent(AgentProtocol):
-    """A2A client implementation"""
+    """A2A client implementation."""
 
     __SUPPORTED_OUTPUT_MODES: ClassVar[list[str]] = [
         "text",
@@ -169,7 +169,8 @@ class A2AAgent(AgentProtocol):
                 error=str(exception),
             )
             raise AgentInitializationException(
-                f"Failed to initialize A2A client for agent '{self._name}': {exception}"
+                f"Failed to initialize A2A client "
+                f"for agent '{self._name}': {exception}",
             ) from exception
 
         await self._perform_health_check()
@@ -180,7 +181,7 @@ class A2AAgent(AgentProtocol):
         )
 
     async def disconnect(self) -> None:
-        """We don't need to explicitly disconnect the A2A client"""
+        """We don't need to explicitly disconnect the A2A client."""
         return
 
     # ============================================================================
@@ -297,7 +298,7 @@ class A2AAgent(AgentProtocol):
     def _handle_send_message_response(
         self, agent_input: AgentInput, response: ClientEvent | Message
     ) -> Optional[AgentOutput]:
-        """Handle possible response types from the A2A client:
+        """Handle possible response types from the A2A client.
 
         In case of streaming, the response can be either exactly *one* Message,
         or a *series* of tuples of (Task, Optional[TaskUpdateEvent]).
@@ -410,8 +411,8 @@ class A2AAgent(AgentProtocol):
         agent_input: AgentInput,
         task: Task,
     ) -> Optional[AgentOutput]:
-        """If the task status is terminal (i.e., completed, failed, etc.),
-        return an AgentOutput.
+        """If task status is terminal (e.g. completed, failed) return AgentOutput.
+
         If the task is still in progress (i.e., submitted, working), return None,
         so that the streaming or pooling agent can continue to wait for updates.
         """
@@ -655,6 +656,7 @@ class A2AAgent(AgentProtocol):
     @staticmethod
     def _generate_completed_response_message(task: Task) -> str:
         """Generate a response message for a completed task.
+
         In case of completed tasks, the final message might be in
         the task status message or in the artifacts (or both).
         """
@@ -728,19 +730,19 @@ class A2AAgent(AgentProtocol):
 
         except FileNotFoundError as e:
             raise AgentInitializationException(
-                f"Agent card file not found: {agent_card_path}"
+                f"Agent card file not found: {agent_card_path}",
             ) from e
         except (IOError, PermissionError) as e:
             raise AgentInitializationException(
-                f"Error reading agent card file {agent_card_path}: {e}"
+                f"Error reading agent card file {agent_card_path}: {e}",
             ) from e
         except json.JSONDecodeError as e:
             raise AgentInitializationException(
-                f"Invalid JSON in agent card file {agent_card_path}: {e}"
+                f"Invalid JSON in agent card file {agent_card_path}: {e}",
             ) from e
         except ValidationError as e:
             raise AgentInitializationException(
-                f"Failed to load agent card from {agent_card_path}: {e}"
+                f"Failed to load agent card from {agent_card_path}: {e}",
             ) from e
 
     @staticmethod
@@ -798,7 +800,7 @@ class A2AAgent(AgentProtocol):
 
         raise AgentInitializationException(
             f"Failed to resolve agent card from {agent_card_path} after "
-            f"{max_retries} attempts."
+            f"{max_retries} attempts.",
         )
 
     # ============================================================================

rasa/agents/protocol/mcp/mcp_base_agent.py

@@ -1,9 +1,10 @@
 import json
 from abc import abstractmethod
-from datetime import datetime
+from datetime import datetime, timedelta
 from inspect import isawaitable
 from typing import Any, Dict, List, Optional, Tuple
 
+import anyio
 import structlog
 from jinja2 import Template
 from mcp import ListToolsResult
@@ -75,6 +76,8 @@ class MCPBaseAgent(AgentProtocol):
 
     MAX_ITERATIONS = 10
 
+    TOOL_CALL_DEFAULT_TIMEOUT = 10  # seconds
+
     # ============================================================================
     # Initialization & Setup
     # ============================================================================
@@ -288,14 +291,16 @@ class MCPBaseAgent(AgentProtocol):
                         event_info="All connection attempts failed.",
                     )
                     raise AgentInitializationException(
-                        f"Failed to connect to MCP servers after {self._max_retries} "
-                        f"attempts. Agent `{self._name}` failed to initialize."
+                        f"Agent `{self._name}` failed to initialize. Failed to connect "
+                        f"to MCP servers after {self._max_retries} attempts. {ce!s}"
                     ) from ce
             except (Exception, AuthenticationError) as e:
                 if isinstance(e, AuthenticationError):
-                    event_info = "Authentication error during agent initialization."
+                    event_info = (
+                        f"Authentication error during agent initialization. {e!s}"
+                    )
                 else:
-                    event_info = "Unexpected error during agent initialization."
+                    event_info = f"Unexpected error during agent initialization. {e!s}"
                 structlogger.error(
                     "mcp_agent.connect.unexpected_exception",
                     event_info=event_info,
@@ -303,7 +308,7 @@ class MCPBaseAgent(AgentProtocol):
                     agent_name=self._name,
                     agent_id=str(make_agent_identifier(self._name, self.protocol_type)),
                 )
-                raise AgentInitializationException(e) from e
+                raise AgentInitializationException(event_info) from e
 
     async def connect_to_server(self, server_config: AgentMCPServerConfig) -> None:
         server_name = server_config.name
@@ -325,7 +330,7 @@ class MCPBaseAgent(AgentProtocol):
         except Exception as e:
             event_info = (
                 f"Agent `{self._name}` failed to connect to MCP server - "
-                f"`{server_name}` @ `{server_config.url}`: {e!s}"
+                f"`{server_name}` @ `{server_config.url}`"
             )
             structlogger.error(
                 "mcp_agent.connect.failed_to_connect",
@@ -335,7 +340,9 @@ class MCPBaseAgent(AgentProtocol):
                 agent_name=self._name,
                 agent_id=str(make_agent_identifier(self._name, self.protocol_type)),
             )
-            raise e
+
+            # Wrap exceptions with extra info and raise the same type of exception.
+            raise type(e)(f"{event_info} : {e!s}") from e
 
     async def connect_to_servers(self) -> None:
         """Connect to MCP servers."""
@@ -624,7 +631,11 @@ class MCPBaseAgent(AgentProtocol):
         connection = self._server_connections[server_id]
         try:
             session = await connection.ensure_active_session()
-            result = await session.call_tool(tool_name, arguments)
+            result = await session.call_tool(
+                tool_name,
+                arguments,
+                read_timeout_seconds=timedelta(seconds=self.TOOL_CALL_DEFAULT_TIMEOUT),
+            )
             return AgentToolResult.from_mcp_tool_result(tool_name, result)
         except Exception as e:
             return AgentToolResult(
@@ -637,6 +648,21 @@ class MCPBaseAgent(AgentProtocol):
                 ),
             )
 
+    async def _run_custom_tool(
+        self, custom_tool: CustomToolSchema, arguments: Dict[str, Any]
+    ) -> AgentToolResult:
+        """Run a custom tool and return the result.
+
+        Args:
+            custom_tool: The custom tool schema containing the tool executor.
+            arguments: The arguments to pass to the tool executor.
+
+        Returns:
+            The result of the tool execution as an AgentToolResult.
+        """
+        result = custom_tool.tool_executor(arguments)
+        return await result if isawaitable(result) else result
+
     async def _execute_tool_call(
         self, tool_name: str, arguments: Dict[str, Any]
     ) -> AgentToolResult:
@@ -655,8 +681,20 @@ class MCPBaseAgent(AgentProtocol):
         try:
             for custom_tool in self._custom_tools:
                 if custom_tool.tool_name == tool_name:
-                    result = custom_tool.tool_executor(arguments)
-                    return await result if isawaitable(result) else result
+                    try:
+                        with anyio.fail_after(self.TOOL_CALL_DEFAULT_TIMEOUT):
+                            return await self._run_custom_tool(custom_tool, arguments)
+
+                    except TimeoutError:
+                        return AgentToolResult(
+                            tool_name=tool_name,
+                            result=None,
+                            is_error=True,
+                            error_message=(
+                                f"Built-in tool `{tool_name}` timed out after "
+                                f"{self.TOOL_CALL_DEFAULT_TIMEOUT} seconds."
+                            ),
+                        )
         except Exception as e:
             return AgentToolResult(
                 tool_name=tool_name,

rasa/agents/validation.py

@@ -347,9 +347,11 @@ def _handle_pydantic_validation_error(
 def _validate_endpoint_references(agent_config: AgentConfig) -> None:
     """Validate that LLM and MCP server references in agent config are valid."""
     agent_name = agent_config.agent.name
-
-    # Get available endpoints
     endpoints = Configuration.get_instance().endpoints
+    if not endpoints.config_file_path:
+        # If no endpoints were loaded (e.g., `data validate` without --endpoints), skip
+        # endpoint reference checks
+        return
 
     # Validate LLM configuration references
     if agent_config.configuration and agent_config.configuration.llm:

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/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/builder/copilot/copilot_templated_message_provider.py

@@ -2,7 +2,7 @@ import importlib.resources
 from typing import Dict
 
 import structlog
-import yaml  # type: ignore
+import yaml  # type: ignore[import-untyped]
 
 from rasa.builder.copilot.constants import (
     COPILOT_HANDLER_RESPONSES_FILE,

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,
@@ -612,16 +613,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 +786,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/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/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}"
         """
     )