rasa-pro 3.14.0.dev7__py3-none-any.whl → 3.14.0.dev8__py3-none-any.whl

rasa/agents/protocol/mcp/mcp_base_agent.py

@@ -10,7 +10,7 @@ from mcp import ListToolsResult
 from rasa.agents.constants import (
     AGENT_DEFAULT_MAX_RETRIES,
     AGENT_DEFAULT_TIMEOUT_SECONDS,
-    AGENT_METADATA_TOOL_RESULTS_KEY,
+    AGENT_METADATA_STRUCTURED_RESULTS_KEY,
     KEY_ARGUMENTS,
     KEY_CONTENT,
     KEY_FUNCTION,
@@ -45,7 +45,7 @@ from rasa.shared.constants import (
     TIMEOUT_CONFIG_KEY,
 )
 from rasa.shared.core.events import BotUttered, UserUttered
-from rasa.shared.exceptions import AgentInitializationException
+from rasa.shared.exceptions import AgentInitializationException, AuthenticationError
 from rasa.shared.providers.llm.llm_response import LLMResponse, LLMToolCall
 from rasa.shared.utils.constants import LOG_COMPONENT_SOURCE_METHOD_INIT
 from rasa.shared.utils.llm import (
@@ -267,10 +267,14 @@ class MCPBaseAgent(AgentProtocol):
                         f"Failed to connect to MCP servers after {self._max_retries} "
                         f"attempts. Agent `{self._name}` failed to initialize."
                     ) from ce
-            except Exception as e:
+            except (Exception, AuthenticationError) as e:
+                if isinstance(e, AuthenticationError):
+                    event_info = "Authentication error during agent initialization."
+                else:
+                    event_info = "Unexpected error during agent initialization."
                 structlogger.error(
                     "mcp_agent.connect.unexpected_exception",
-                    event_info="Unexpected error during agent initialization.",
+                    event_info=event_info,
                     error=str(e),
                     agent_name=self._name,
                     agent_id=str(make_agent_identifier(self._name, self.protocol_type)),
@@ -307,7 +311,7 @@ class MCPBaseAgent(AgentProtocol):
                 agent_name=self._name,
                 agent_id=str(make_agent_identifier(self._name, self.protocol_type)),
             )
-            raise ConnectionError(e)
+            raise e
 
     async def connect_to_servers(self) -> None:
         """Connect to MCP servers."""
@@ -549,6 +553,19 @@ class MCPBaseAgent(AgentProtocol):
             KEY_CONTENT: tool_response.response_message,
         }
 
+    def _get_system_message_for_malformed_tool_response(self) -> Dict[str, Any]:
+        """Get the system message for a malformed tool response."""
+        system_message = (
+            "The previous tool response contained invalid or incomplete JSON and could"
+            "not be parsed. Retry by generating a tool response in STRICT JSON string "
+            "format only. Ensure the JSON is fully well-formed and corresponds exactly "
+            "to the user's last request."
+        )
+        return {
+            KEY_ROLE: ROLE_SYSTEM,
+            KEY_CONTENT: system_message,
+        }
+
     # ============================================================================
     # Tool Execution
     # ============================================================================
@@ -640,24 +657,24 @@ class MCPBaseAgent(AgentProtocol):
                 error_message=tool_output.error_message,
             )
 
-    def _get_tool_results_for_agent_output(
+    def _get_structured_results_for_agent_output(
         self,
         agent_input: AgentInput,
         current_tool_results: Dict[str, AgentToolResult],
     ) -> List[List[Dict[str, Any]]]:
         """Get the tool results for the agent output."""
-        tool_results_of_current_iteration: List[Dict[str, Any]] = []
+        structured_results_of_current_iteration: List[Dict[str, Any]] = []
         for tool_result in current_tool_results.values():
-            tool_results_of_current_iteration.append(
-                {"tool_name": tool_result.tool_name, "result": tool_result.result}
+            structured_results_of_current_iteration.append(
+                {"name": tool_result.tool_name, "result": tool_result.result}
             )
 
-        previous_tool_results: List[List[Dict[str, Any]]] = (
-            agent_input.metadata.get(AGENT_METADATA_TOOL_RESULTS_KEY, []) or []
+        previous_structured_results: List[List[Dict[str, Any]]] = (
+            agent_input.metadata.get(AGENT_METADATA_STRUCTURED_RESULTS_KEY, []) or []
         )
-        previous_tool_results.append(tool_results_of_current_iteration)
+        previous_structured_results.append(structured_results_of_current_iteration)
 
-        return previous_tool_results
+        return previous_structured_results
 
     # ============================================================================
     # Core Protocol Methods

rasa/agents/protocol/mcp/mcp_open_agent.py

@@ -31,6 +31,10 @@ from rasa.shared.agents.utils import make_agent_identifier
 from rasa.shared.constants import (
     ROLE_TOOL,
 )
+from rasa.shared.exceptions import (
+    LLMToolResponseDecodeError,
+    ProviderClientAPIException,
+)
 from rasa.shared.providers.llm.llm_response import LLMResponse, LLMToolCall
 
 DEFAULT_OPEN_AGENT_PROMPT_TEMPLATE = importlib.resources.read_text(
@@ -130,7 +134,7 @@ class MCPOpenAgent(MCPBaseAgent):
             id=agent_input.id,
             status=AgentStatus.COMPLETED,
             response_message=tool_result.result,
-            tool_results=self._get_tool_results_for_agent_output(
+            structured_results=self._get_structured_results_for_agent_output(
                 agent_input, tool_results
             ),
         )
@@ -178,7 +182,7 @@ class MCPOpenAgent(MCPBaseAgent):
                         id=agent_input.id,
                         status=AgentStatus.RECOVERABLE_ERROR,
                         error_message=event_info,
-                        tool_results=self._get_tool_results_for_agent_output(
+                        structured_results=self._get_structured_results_for_agent_output(
                             agent_input, tool_results
                         ),
                     )
@@ -189,7 +193,7 @@ class MCPOpenAgent(MCPBaseAgent):
                         id=agent_input.id,
                         status=AgentStatus.INPUT_REQUIRED,
                         response_message=llm_response.choices[0],
-                        tool_results=self._get_tool_results_for_agent_output(
+                        structured_results=self._get_structured_results_for_agent_output(
                             agent_input, tool_results
                         ),
                     )
@@ -258,9 +262,28 @@ class MCPOpenAgent(MCPBaseAgent):
                             )
 
             except Exception as e:
-                # TODO: To log the ProviderClientAPIException separately, so that
-                # malformed tool responses automatically trigger a retry, and are
-                # not cached.
+                if isinstance(e, ProviderClientAPIException) and isinstance(
+                    e.original_exception, LLMToolResponseDecodeError
+                ):
+                    structlogger.debug(
+                        "mcp_open_agent.send_message.malformed_tool_response_error",
+                        event_info=(
+                            "Malformed tool response received from LLM "
+                            "(JSON decode error). Retrying the LLM call."
+                        ),
+                        user_message=agent_input.user_message,
+                        agent_name=self._name,
+                        agent_id=str(
+                            make_agent_identifier(self._name, self.protocol_type)
+                        ),
+                        original_exception=str(e.original_exception),
+                    )
+                    # Continue to make another LLM call by breaking out of the current
+                    # iteration and letting the loop continue with a fresh LLM request
+                    messages.append(
+                        self._get_system_message_for_malformed_tool_response()
+                    )
+                    continue
                 structlogger.error(
                     "mcp_open_agent.send_message.error_in_agent_loop",
                     event_info=f"Failed to send message: {e}",
@@ -272,7 +295,7 @@ class MCPOpenAgent(MCPBaseAgent):
                     id=agent_input.id,
                     status=AgentStatus.FATAL_ERROR,
                     response_message=f"I encountered an error: {e!s}",
-                    tool_results=self._get_tool_results_for_agent_output(
+                    structured_results=self._get_structured_results_for_agent_output(
                         agent_input, tool_results
                     ),
                     error_message=str(e),
@@ -284,7 +307,7 @@ class MCPOpenAgent(MCPBaseAgent):
                 "I've completed my research but couldn't provide a final answer within"
                 "the allowed steps."
             ),
-            tool_results=self._get_tool_results_for_agent_output(
+            structured_results=self._get_structured_results_for_agent_output(
                 agent_input, tool_results
             ),
         )

rasa/agents/protocol/mcp/mcp_task_agent.py

@@ -27,6 +27,10 @@ from rasa.shared.constants import (
     ROLE_TOOL,
 )
 from rasa.shared.core.events import SlotSet
+from rasa.shared.exceptions import (
+    LLMToolResponseDecodeError,
+    ProviderClientAPIException,
+)
 from rasa.shared.providers.llm.llm_response import LLMResponse
 
 DEFAULT_TASK_AGENT_PROMPT_TEMPLATE = importlib.resources.read_text(
@@ -241,7 +245,7 @@ class MCPTaskAgent(MCPBaseAgent):
                 for slot_name, slot_value in slots.items()
                 if slot_name in _slot_names_to_be_filled
             ],
-            tool_results=self._get_tool_results_for_agent_output(
+            structured_results=self._get_structured_results_for_agent_output(
                 agent_input, tool_results
             ),
         )
@@ -303,7 +307,7 @@ class MCPTaskAgent(MCPBaseAgent):
                         id=agent_input.id,
                         status=AgentStatus.RECOVERABLE_ERROR,
                         error_message=event_info,
-                        tool_results=self._get_tool_results_for_agent_output(
+                        structured_results=self._get_structured_results_for_agent_output(
                             agent_input, tool_results
                         ),
                     )
@@ -314,7 +318,7 @@ class MCPTaskAgent(MCPBaseAgent):
                         id=agent_input.id,
                         status=AgentStatus.INPUT_REQUIRED,
                         response_message=llm_response.choices[0],
-                        tool_results=self._get_tool_results_for_agent_output(
+                        structured_results=self._get_structured_results_for_agent_output(
                             agent_input, tool_results
                         ),
                     )
@@ -445,16 +449,35 @@ class MCPTaskAgent(MCPBaseAgent):
                                     "An internal error occurred while checking the "
                                     "exit conditions."
                                 ),
-                                tool_results=self._get_tool_results_for_agent_output(
+                                structured_results=self._get_structured_results_for_agent_output(
                                     agent_input, tool_results
                                 ),
                                 error_message=internal_error,
                             )
 
             except Exception as e:
-                # TODO: To log the ProviderClientAPIException separately, so that
-                # malformed tool responses automatically trigger a retry, and are
-                # not cached.
+                if isinstance(e, ProviderClientAPIException) and isinstance(
+                    e.original_exception, LLMToolResponseDecodeError
+                ):
+                    structlogger.debug(
+                        "mcp_task_agent.send_message.malformed_tool_response_error",
+                        event_info=(
+                            "Malformed tool response received from LLM "
+                            "(JSON decode error). Retrying the LLM call."
+                        ),
+                        user_message=agent_input.user_message,
+                        agent_name=self._name,
+                        agent_id=str(
+                            make_agent_identifier(self._name, self.protocol_type)
+                        ),
+                        original_exception=str(e.original_exception),
+                    )
+                    # Continue to make another LLM call by breaking out of the current
+                    # iteration and letting the loop continue with a fresh LLM request
+                    messages.append(
+                        self._get_system_message_for_malformed_tool_response()
+                    )
+                    continue
                 structlogger.error(
                     "mcp_task_agent.send_message.error_in_agent_loop",
                     event_info=f"Failed to send message: {e}",
@@ -466,7 +489,7 @@ class MCPTaskAgent(MCPBaseAgent):
                     id=agent_input.id,
                     status=AgentStatus.FATAL_ERROR,
                     response_message=f"I encountered an error: {e!s}",
-                    tool_results=self._get_tool_results_for_agent_output(
+                    structured_results=self._get_structured_results_for_agent_output(
                         agent_input, tool_results
                     ),
                     error_message=str(e),
@@ -478,7 +501,7 @@ class MCPTaskAgent(MCPBaseAgent):
                 "I've completed my research but couldn't provide a final answer within"
                 "the allowed steps."
             ),
-            tool_results=self._get_tool_results_for_agent_output(
+            structured_results=self._get_structured_results_for_agent_output(
                 agent_input, tool_results
             ),
         )

rasa/agents/schemas/agent_output.py

@@ -13,7 +13,7 @@ class AgentOutput(BaseModel):
     status: AgentStatus
     response_message: Optional[str] = None
     events: Optional[List[SlotSet]] = None
-    tool_results: Optional[List[List[Dict[str, Any]]]] = None
+    structured_results: Optional[List[List[Dict[str, Any]]]] = None
     metadata: Optional[Dict[str, Any]] = None
     timestamp: Optional[str] = None
     error_message: Optional[str] = None

rasa/agents/utils.py

@@ -1,4 +1,4 @@
-from typing import List, Optional
+from typing import Dict, List, Optional
 
 from rasa.agents.agent_manager import AgentManager
 from rasa.agents.exceptions import AgentNotFoundException
@@ -11,8 +11,10 @@ from rasa.core.available_agents import (
 from rasa.core.available_endpoints import AvailableEndpoints
 from rasa.shared.agents.utils import get_protocol_type
 from rasa.shared.core.domain import Domain
+from rasa.shared.core.events import AgentCompleted
 from rasa.shared.core.flows import FlowsList
 from rasa.shared.core.flows.steps import CallFlowStep
+from rasa.shared.core.trackers import DialogueStateTracker
 
 
 def resolve_agent_config(
@@ -34,6 +36,7 @@ def resolve_agent_config(
             if mcp_server_endpoint.name == mcp_server.name:
                 mcp_server.url = mcp_server_endpoint.url
                 mcp_server.type = mcp_server_endpoint.type
+                mcp_server.additional_params = mcp_server_endpoint.additional_params
 
     return agent_config
 
@@ -75,3 +78,89 @@ async def initialize_agents(
                     protocol_type,
                     resolved_agent_config,
                 )
+
+
+def is_agent_valid(agent_id: str) -> bool:
+    """Check if an agent ID references a valid agent.
+
+    Args:
+        agent_id: The agent ID to validate.
+
+    Returns:
+        True if the agent exists, False otherwise.
+    """
+    agent_config = AvailableAgents.get_agent_config(agent_id)
+    return agent_config is not None
+
+
+def is_agent_completed(tracker: DialogueStateTracker, agent_id: str) -> bool:
+    """Check if an agent has been completed.
+
+    Args:
+        tracker: The dialogue state tracker.
+        agent_id: The agent ID to check.
+
+    Returns:
+        True if the agent has been completed, False otherwise.
+    """
+    # Look for AgentCompleted events for this agent
+    for event in reversed(tracker.events):
+        if isinstance(event, AgentCompleted) and event.agent_id == agent_id:
+            return True
+    return False
+
+
+def get_agent_info(agent_id: str) -> Optional[Dict[str, str]]:
+    """Get basic agent information (name and description).
+
+    Args:
+        agent_id: The agent ID to get information for.
+
+    Returns:
+        Dictionary with agent name and description if found, None otherwise.
+    """
+    agent_config = AvailableAgents.get_agent_config(agent_id)
+    if agent_config is None:
+        return None
+
+    return {
+        "name": agent_config.agent.name,
+        "description": agent_config.agent.description,
+    }
+
+
+def get_completed_agents_info(tracker: DialogueStateTracker) -> List[Dict[str, str]]:
+    """Get information for all completed agents.
+
+    Args:
+        tracker: The dialogue state tracker.
+
+    Returns:
+        List of dictionaries containing agent information for completed agents.
+    """
+    completed_agents = []
+    for event in reversed(tracker.events):
+        if isinstance(event, AgentCompleted):
+            agent_info = get_agent_info(event.agent_id)
+            if agent_info:
+                completed_agents.append(agent_info)
+    return completed_agents
+
+
+def get_active_agent_info(
+    tracker: DialogueStateTracker, flow_id: str
+) -> Optional[Dict[str, str]]:
+    """Get information for the active agent in a specific flow.
+
+    Args:
+        tracker: The dialogue state tracker.
+        flow_id: The flow ID to get the active agent for.
+
+    Returns:
+        Dictionary with agent name and description if an agent is active,
+        None otherwise.
+    """
+    agent_frame = tracker.stack.find_active_agent_stack_frame_for_flow(flow_id)
+    if agent_frame:
+        return get_agent_info(agent_frame.agent_id)
+    return None

rasa/builder/README.md

@@ -0,0 +1,120 @@
+# Rasa Prompt-to-Bot Service
+
+A production-ready service that generates Rasa chatbots from natural language descriptions using LLMs.
+
+## Architecture
+
+The service follows functional programming principles with minimal use of classes:
+
+### Core Modules
+
+- **`config.py`** - Configuration management using module-level constants
+- **`exceptions.py`** - Custom exception hierarchy for error handling
+- **`models.py`** - Pydantic models for request/response validation
+- **`llm_service.py`** - LLM interactions (minimal class for state management)
+- **`validation_service.py`** - Project validation functions
+- **`training_service.py`** - Model training functions
+- **`project_generator.py`** - Project generation (class for bot files state)
+- **`service.py`** - Main orchestrating service (class for app state)
+- **`logging_utils.py`** - Thread-safe logging utilities
+- **`llm_context.py`** - Conversation context formatting
+- **`main.py`** - Application entry point
+
+### Utility Scripts
+
+- **`scrape_rasa_docs.py`** - Documentation scraping
+- **`create_openai_vector_store.py`** - Documentation indexing
+
+## Key Design Principles
+
+1. **Functional First**: Use functions for stateless operations
+2. **Minimal Classes**: Classes only when state management is needed
+3. **Configuration**: Environment variables with sensible defaults
+4. **Error Handling**: Structured exception hierarchy
+5. **Type Safety**: Full type annotations and Pydantic validation
+6. **Thread Safety**: Safe concurrent operations
+7. **Resource Management**: Proper cleanup and lifecycle handling
+
+## Usage
+
+### Running the Service
+
+```bash
+python rasa/builder/main.py
+```
+
+### Environment Configuration
+
+```bash
+# OpenAI Settings
+export OPENAI_MODEL="gpt-4.1-2025-04-14"
+export OPENAI_TEMPERATURE="0.7"
+export OPENAI_VECTOR_STORE_ID="vs_xxxxx"
+export OPENAI_TIMEOUT="30"
+
+# Server Settings
+export SERVER_HOST="0.0.0.0"
+export SERVER_PORT="5005"
+export MAX_RETRIES="5"
+export CORS_ORIGINS="http://localhost:3000,https://example.com"
+
+# Validation Settings
+export VALIDATION_FAIL_ON_WARNINGS="false"
+```
+
+### API Endpoints
+
+- `POST /api/prompt-to-bot` - Generate bot from description
+- `GET /api/bot-data` - Get current bot configuration
+- `PUT /api/bot-data` - Update bot configuration (SSE)
+- `POST /api/llm-builder` - LLM helper for bot development
+- `GET /` - Health check
+
+### Documentation Setup
+
+```bash
+# 1. Scrape Rasa documentation
+python rasa/builder/scrape_rasa_docs.py
+
+# 2. Create OpenAI vector store
+python rasa/builder/create_openai_vector_store.py
+```
+
+## Benefits of Functional Approach
+
+- **Simpler**: Easy to understand and reason about
+- **Testable**: Functions are easier to unit test
+- **Reusable**: Pure functions can be composed
+- **Maintainable**: Clear separation of concerns
+- **Performant**: No unnecessary object overhead
+- **Debuggable**: Clear call stacks and data flow
+
+## Error Handling
+
+The service uses a structured exception hierarchy:
+
+- `PromptToBotError` - Base exception
+- `ValidationError` - Project validation failures
+- `TrainingError` - Model training issues
+- `LLMGenerationError` - LLM API problems
+- `ProjectGenerationError` - Generation retry exhaustion
+- `AgentLoadError` - Agent loading failures
+
+## Logging
+
+Structured logging with context using `structlog`:
+
+```python
+structlogger.info("operation.success", key="value")
+structlogger.error("operation.failed", error=str(e))
+```
+
+## State Management
+
+Only classes that truly need state:
+
+1. **`LLMService`** - Caches schemas and manages OpenAI client
+2. **`ProjectGenerator`** - Maintains current bot files
+3. **`BotBuilderService`** - Manages Sanic app and agent state
+
+Everything else uses pure functions for maximum simplicity and testability.