rasa-pro 3.14.0.dev3__py3-none-any.whl → 3.14.0.dev5__py3-none-any.whl

rasa/api.py

@@ -20,7 +20,6 @@ if TYPE_CHECKING:
 def run(
     model: Text,
     endpoints: Text,
-    sub_agents: Text,
     connector: Optional[Text] = None,
     credentials: Optional[Text] = None,
     **kwargs: Dict[Text, Any],
@@ -30,7 +29,6 @@ def run(
     Args:
         model: Path to model archive.
         endpoints: Path to endpoints file.
-        sub_agents: Path to sub-agents directory.
         connector: Connector which should be use (overwrites `credentials`
         field).
         credentials: Path to channel credentials file.
@@ -40,13 +38,11 @@ def run(
     """
     import rasa.core.run
     import rasa.shared.utils.common
-    from rasa.core.available_agents import AvailableAgents
     from rasa.core.available_endpoints import AvailableEndpoints
     from rasa.shared.constants import DOCS_BASE_URL
     from rasa.shared.utils.cli import print_warning
 
     _endpoints = AvailableEndpoints.get_instance(endpoints)
-    _sub_agents = AvailableAgents.get_instance(sub_agents)
 
     if not connector and not credentials:
         connector = "rest"
@@ -65,7 +61,6 @@ def run(
         channel=connector,
         credentials=credentials,
         endpoints=_endpoints,
-        sub_agents=_sub_agents,
         **kwargs,
     )
 

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.

rasa/builder/auth.py

@@ -0,0 +1,176 @@
+"""Authentication utilities for bot builder service."""
+
+from datetime import datetime, timedelta, timezone
+from functools import wraps
+from typing import Any, Awaitable, Callable, Dict, Optional, Tuple
+
+import jwt
+import structlog
+from jwt import PyJWKClient
+from pydantic import BaseModel
+from sanic import response
+from sanic.request import Request
+from sanic.response import HTTPResponse
+
+from rasa.builder.config import (
+    AUTH0_CLIENT_ID,
+    AUTH0_ISSUER,
+    AUTH_REQUIRED_AFTER_MINUTES,
+    JWKS_URL,
+)
+from rasa.builder.models import ApiErrorResponse
+from rasa.builder.project_info import ProjectInfo
+
+HEADER_USER_ID = "X-User-Id"
+
+structlogger = structlog.get_logger()
+
+RouteHandler = Callable[..., Awaitable[HTTPResponse]]
+ProtectedDecorator = Callable[[RouteHandler], RouteHandler]
+
+
+def verify_auth0_token(token: str) -> Dict[str, Any]:
+    """Verify JWT token from Auth0.
+
+    Args:
+        token: JWT token string
+
+    Returns:
+        Dict containing the token payload
+
+    Raises:
+        Exception: If token verification fails
+    """
+    jwk_client = PyJWKClient(JWKS_URL)
+    signing_key = jwk_client.get_signing_key_from_jwt(token)
+
+    payload = jwt.decode(
+        token,
+        signing_key.key,
+        algorithms=["RS256"],
+        audience=AUTH0_CLIENT_ID,
+        issuer=AUTH0_ISSUER,
+    )
+    return payload
+
+
+class Auth0TokenVerificationResult(BaseModel):
+    payload: Optional[Dict[str, Any]]
+    error_message: Optional[str]
+
+
+def extract_and_verify_auth0_token(
+    auth_header: str,
+) -> Auth0TokenVerificationResult:
+    """Extract and verify JWT token from Authorization header.
+
+    Args:
+        auth_header: Authorization header value
+
+    Returns:
+        Auth0TokenVerificationResult: Contains payload and error_message.
+    """
+    # Check Authorization header format
+    if not auth_header.startswith("Bearer "):
+        return Auth0TokenVerificationResult(
+            payload=None, error_message="Missing or invalid Authorization header"
+        )
+
+    # Extract token
+    token = auth_header.split(" ")[1]
+
+    # Verify token
+    try:
+        payload = verify_auth0_token(token)
+        return Auth0TokenVerificationResult(payload=payload, error_message=None)
+    except Exception as e:
+        return Auth0TokenVerificationResult(
+            payload=None, error_message=f"Invalid token: {e!s}"
+        )
+
+
+def is_auth_required_now(
+    *, always_required: bool = False, project_info: Optional[ProjectInfo] = None
+) -> bool:
+    """Return whether authentication is required right now based on config.
+
+    - If always_required is True, returns True
+    - Else, returns True iff current UTC time >= first_used + configured delta
+    """
+    if always_required:
+        return True
+    now = datetime.now(timezone.utc)
+
+    if project_info is None:
+        return False
+
+    first_used = project_info.first_used_dt()
+    if first_used is None:
+        return False
+
+    delta = timedelta(minutes=AUTH_REQUIRED_AFTER_MINUTES)
+    auth_required_start = (first_used + delta).astimezone(timezone.utc)
+    return now >= auth_required_start
+
+
+def _check_and_attach_auth(request: Any) -> Tuple[bool, Optional[str]]:
+    """Validate Authorization header. On success, store payload on request.ctx."""
+    auth_header = request.headers.get("Authorization", "")
+    verification_result = extract_and_verify_auth0_token(auth_header)
+    if verification_result.error_message is not None:
+        return False, verification_result.error_message
+
+    # Attach payload for downstream consumers
+    try:
+        request.ctx.auth_payload = verification_result.payload
+    except Exception:
+        # If ctx is not available for some reason, ignore silently
+        pass
+    return True, None
+
+
+def protected(*, always_required: bool = False) -> ProtectedDecorator:
+    """Decorator to protect routes with conditional authentication.
+
+    Authentication rules:
+    - If always_required=True: token is always required
+    - Else: token is required only after RASA_AUTH_AFTER timestamp
+
+    On failure returns a 401 with a JSON error body.
+    """
+
+    def decorator(f: RouteHandler) -> RouteHandler:
+        @wraps(f)
+        async def decorated_function(
+            request: Request, *args: Any, **kwargs: Any
+        ) -> HTTPResponse:
+            # Global bypass: allow turning off auth entirely
+            if not getattr(request.app.config, "USE_AUTHENTICATION", True):
+                return await f(request, *args, **kwargs)
+
+            project_info: Optional[ProjectInfo] = None
+            try:
+                project_info = request.app.ctx.project_generator.project_info
+            except Exception:
+                project_info = None
+
+            if is_auth_required_now(
+                always_required=always_required, project_info=project_info
+            ):
+                ok, err = _check_and_attach_auth(request)
+                if not ok:
+                    structlogger.error(
+                        "builder.auth.token_verification_failed", error=err
+                    )
+                    return response.json(
+                        ApiErrorResponse(
+                            error=err,
+                            details={"expected": "Bearer <valid_token>"},
+                        ).model_dump(),
+                        status=401,
+                    )
+            return await f(request, *args, **kwargs)
+
+        return decorated_function
+
+    return decorator

rasa/builder/config.py

@@ -0,0 +1,115 @@
+"""Configuration module for the prompt-to-bot service."""
+
+import os
+from typing import Any, Dict
+
+import importlib_resources
+
+from rasa.constants import PACKAGE_NAME
+from rasa.shared.utils.yaml import read_yaml, read_yaml_file
+
+# OpenAI Configuration
+OPENAI_MODEL = os.getenv("OPENAI_MODEL", "gpt-4.1-2025-04-14")
+OPENAI_TEMPERATURE = float(os.getenv("OPENAI_TEMPERATURE", "0.7"))
+OPENAI_VECTOR_STORE_ID = os.getenv(
+    "OPENAI_VECTOR_STORE_ID", "vs_685123376e288191a005b6b144d3026f"
+)
+OPENAI_MAX_VECTOR_RESULTS = int(os.getenv("OPENAI_MAX_VECTOR_RESULTS", "10"))
+OPENAI_TIMEOUT = int(os.getenv("OPENAI_TIMEOUT", "30"))
+
+# Server Configuration
+BUILDER_SERVER_HOST = os.getenv("SERVER_HOST", "0.0.0.0")
+BUILDER_SERVER_PORT = int(os.getenv("SERVER_PORT", "5050"))
+MAX_RETRIES = int(os.getenv("MAX_RETRIES", "5"))
+MAX_LOG_ENTRIES = int(os.getenv("MAX_LOG_ENTRIES", "30"))
+HELLO_RASA_PROJECT_ID = os.getenv("HELLO_RASA_PROJECT_ID")
+
+# CORS Configuration
+_cors_origins_env = os.getenv("CORS_ORIGINS", "*")
+CORS_ORIGINS = _cors_origins_env.split(",") if _cors_origins_env != "*" else ["*"]
+
+# Validation Configuration
+VALIDATION_FAIL_ON_WARNINGS = (
+    os.getenv("VALIDATION_FAIL_ON_WARNINGS", "false").lower() == "true"
+)
+VALIDATION_MAX_HISTORY = None  # Could be configured if needed
+
+# Copilot Response Handler Configuration
+COPILOT_CONTROLLED_RESPONSE_MAX_TOKENS = 20
+COPILOT_HANDLER_ROLLING_BUFFER_SIZE = 20
+COPILOT_ASSISTANT_TRACKER_MAX_TURNS = 10
+
+# Guardrail Configuration
+LAKERA_BASE_URL = os.getenv("LAKERA_BASE_URL", "https://api.lakera.ai/v2").rstrip("/")
+ASSISTANT_HISTORY_GUARDRAIL_PROJECT_ID = "project-5442154580"
+COPILOT_HISTORY_GUARDRAIL_PROJECT_ID = "project-4637497223"
+
+# Auth0 Configuration
+AUTH0_DOMAIN = "login.hello.rasa.ai"
+AUTH0_CLIENT_ID = "Gq5RdRwp174OFIfTz6Re9TZUseYDXUYE"
+AUTH0_ISSUER = f"https://{AUTH0_DOMAIN}/"
+JWKS_URL = f"{AUTH0_ISSUER}.well-known/jwks.json"
+
+# Inkeep Configuration
+INKEEP_BASE_URL = os.getenv("INKEEP_BASE_URL", "https://api.inkeep.com/v1").rstrip("/")
+
+# LLM Proxy Configuration
+HELLO_LLM_PROXY_BASE_URL = os.getenv("HELLO_LLM_PROXY_BASE_URL")
+RASA_PRO_LICENSE = os.getenv("RASA_PRO_LICENSE")
+
+# Compute proxy-aware base URLs
+if HELLO_LLM_PROXY_BASE_URL:
+    _proxy = HELLO_LLM_PROXY_BASE_URL.rstrip("/")
+    INKEEP_BASE_URL = f"{_proxy}/documentation"
+    LAKERA_BASE_URL = f"{_proxy}/guardrails"
+
+
+# Number of minutes after FIRST_USED when authentication becomes required
+# across routes (except when auth is globally disabled on the server).
+# Default kept small for development; adjust as needed.
+AUTH_REQUIRED_AFTER_MINUTES = int(os.getenv("AUTH_REQUIRED_AFTER_MINUTES", "480"))
+
+
+def get_default_config(assistant_id: str) -> Dict[str, Any]:
+    """Get default Rasa configuration."""
+    base_config = read_yaml_file(
+        str(
+            importlib_resources.files(PACKAGE_NAME).joinpath(
+                "cli/project_templates/default/config.yml"
+            )
+        )
+    )
+
+    if not isinstance(base_config, dict):
+        raise ValueError("Base config is not a dictionary")
+
+    base_config["assistant_id"] = assistant_id
+
+    return base_config
+
+
+def get_default_endpoints() -> Dict[str, Any]:
+    """Get default endpoints configuration."""
+    endpoints_config = read_yaml_file(
+        str(
+            importlib_resources.files(PACKAGE_NAME).joinpath(
+                "cli/project_templates/default/endpoints.yml"
+            )
+        )
+    )
+
+    if not isinstance(endpoints_config, dict):
+        raise ValueError("Endpoints config is not a dictionary")
+
+    return endpoints_config
+
+
+def get_default_credentials() -> Dict[str, Any]:
+    """Get default credentials configuration."""
+    default_credentials_yaml = """
+    studio_chat:
+      user_message_evt: "user_message"
+      bot_message_evt: "bot_message"
+      session_persistence: true
+    """
+    return read_yaml(default_credentials_yaml)

rasa/builder/copilot/constants.py

@@ -0,0 +1,25 @@
+from typing import Literal
+
+# A dot-path for importlib to the copilot prompt
+COPILOT_PROMPTS_DIR = "builder.copilot.prompts"
+COPILOT_PROMPTS_FILE = "copilot_system_prompt.jinja2"
+
+# A dot-path for importlib to the rasa internal messages templates
+COPILOT_MESSAGE_TEMPLATES_DIR = "builder.copilot.templated_messages"
+RASA_INTERNAL_MESSAGES_TEMPLATES_FILE = "copilot_internal_messages_templates.yml"
+COPILOT_HANDLER_RESPONSES_FILE = "copilot_templated_responses.yml"
+
+# OpenAI roles copilot utilizes - Use literal types to avoid type errors with OpenAI
+ROLE_USER: Literal["user"] = "user"
+ROLE_SYSTEM: Literal["system"] = "system"
+ROLE_ASSISTANT: Literal["assistant"] = "assistant"
+
+# Rasa Copilot role - Added to avoid confusion with the assistant role on the frontend.
+ROLE_COPILOT: Literal["copilot"] = "copilot"
+
+# Rasa internal role - Used to indicate that the message is from the Rasa internal
+# system components.
+ROLE_COPILOT_INTERNAL: Literal["copilot_internal"] = "copilot_internal"
+
+# Copilot Telemetry
+COPILOT_SEGMENT_WRITE_KEY_ENV_VAR = "COPILOT_SEGMENT_WRITE_KEY"