rasa-pro 3.14.0.dev20250825__py3-none-any.whl → 3.14.0.dev20250901__py3-none-any.whl

rasa/builder/llm_service.py

@@ -0,0 +1,246 @@
+"""Service for handling LLM interactions."""
+
+import asyncio
+import importlib
+import json
+from contextlib import asynccontextmanager
+from copy import deepcopy
+from typing import Any, AsyncGenerator, Dict, List, Optional
+
+import importlib_resources
+import openai
+import structlog
+from jinja2 import Template
+
+from rasa.builder import config
+from rasa.builder.copilot.copilot import Copilot
+from rasa.builder.copilot.copilot_response_handler import CopilotResponseHandler
+from rasa.builder.copilot.copilot_templated_message_provider import (
+    load_copilot_internal_message_templates,
+)
+from rasa.builder.exceptions import LLMGenerationError
+from rasa.builder.guardrails.lakera import LakeraAIGuardrails
+from rasa.constants import PACKAGE_NAME
+from rasa.shared.constants import DOMAIN_SCHEMA_FILE, RESPONSES_SCHEMA_FILE
+from rasa.shared.core.flows.yaml_flows_io import FLOWS_SCHEMA_FILE
+from rasa.shared.utils.io import read_json_file
+from rasa.shared.utils.yaml import read_schema_file
+
+structlogger = structlog.get_logger()
+
+
+class LLMService:
+    """Handles OpenAI LLM interactions with caching for efficiency."""
+
+    def __init__(self) -> None:
+        self._client: Optional[openai.AsyncOpenAI] = None
+        self._domain_schema: Optional[Dict[str, Any]] = None
+        self._flows_schema: Optional[Dict[str, Any]] = None
+        self._copilot: Optional[Copilot] = None
+        self._guardrails: Optional[LakeraAIGuardrails] = None
+        self._copilot_response_handler: Optional[CopilotResponseHandler] = None
+        self._copilot_internal_message_templates: Optional[Dict[str, str]] = None
+
+    @property
+    def copilot(self) -> Copilot:
+        """Get or lazy create copilot instance."""
+        if self._copilot is None:
+            self._copilot = Copilot()
+
+        try:
+            return self._copilot
+        except Exception as e:
+            structlogger.error(
+                "llm_service.copilot.error",
+                event_info="LLM Service: Error getting copilot instance.",
+                error=str(e),
+            )
+            raise
+
+    @property
+    def copilot_response_handler(self) -> CopilotResponseHandler:
+        """Get or lazy create copilot response handler instance."""
+        if self._copilot_response_handler is None:
+            self._copilot_response_handler = CopilotResponseHandler(
+                rolling_buffer_size=config.COPILOT_HANDLER_ROLLING_BUFFER_SIZE,
+            )
+        try:
+            return self._copilot_response_handler
+        except Exception as e:
+            structlogger.error(
+                "llm_service.copilot_response_handler.error",
+                event_info=(
+                    "LLM Service: Error getting copilot response handler instance."
+                ),
+                error=str(e),
+            )
+            raise
+
+    @property
+    def guardrails(self) -> LakeraAIGuardrails:
+        """Get or lazy create guardrails instance."""
+        if self._guardrails is None:
+            self._guardrails = LakeraAIGuardrails()
+        try:
+            return self._guardrails
+        except Exception as e:
+            structlogger.error(
+                "llm_service.guardrails.error",
+                event_info="LLM Service: Error getting guardrails instance.",
+                error=str(e),
+            )
+            raise
+
+    @property
+    def copilot_internal_message_templates(self) -> Dict[str, str]:
+        """Get or lazy load copilot internal message templates."""
+        if self._copilot_internal_message_templates is None:
+            self._copilot_internal_message_templates = (
+                load_copilot_internal_message_templates()
+            )
+        return self._copilot_internal_message_templates
+
+    @staticmethod
+    def instantiate_copilot() -> Copilot:
+        """Instantiate a new Copilot instance."""
+        return Copilot()
+
+    @staticmethod
+    def instantiate_handler(rolling_buffer_size: int) -> CopilotResponseHandler:
+        """Instantiate a new CopilotResponseHandler instance."""
+        return CopilotResponseHandler(
+            rolling_buffer_size=rolling_buffer_size,
+        )
+
+    @asynccontextmanager
+    async def _get_client(self) -> AsyncGenerator[openai.AsyncOpenAI, None]:
+        """Get or create OpenAI client with proper resource management."""
+        if self._client is None:
+            self._client = openai.AsyncOpenAI(timeout=config.OPENAI_TIMEOUT)
+
+        try:
+            yield self._client
+        except Exception as e:
+            structlogger.error("llm.client_error", error=str(e))
+            raise
+
+    def _prepare_schemas(self) -> None:
+        """Prepare and cache schemas for LLM generation."""
+        if self._domain_schema is None:
+            self._domain_schema = _prepare_domain_schema()
+
+        if self._flows_schema is None:
+            self._flows_schema = _prepare_flows_schema()
+
+    async def generate_rasa_project(
+        self, messages: List[Dict[str, Any]]
+    ) -> Dict[str, Any]:
+        """Generate Rasa project data using OpenAI."""
+        self._prepare_schemas()
+
+        try:
+            async with self._get_client() as client:
+                response_format = {
+                    "type": "json_schema",
+                    "json_schema": {
+                        "name": "rasa_project",
+                        "schema": {
+                            "type": "object",
+                            "properties": {
+                                "domain": self._domain_schema,
+                                "flows": self._flows_schema,
+                            },
+                            "required": ["domain", "flows"],
+                        },
+                    },
+                }
+                response = await client.chat.completions.create(  # type: ignore
+                    model=config.OPENAI_MODEL,
+                    messages=messages,
+                    temperature=config.OPENAI_TEMPERATURE,
+                    response_format=response_format,
+                )
+
+                content = response.choices[0].message.content
+                if not content:
+                    raise LLMGenerationError("Empty response from LLM")
+
+                try:
+                    return json.loads(content)
+                except json.JSONDecodeError as e:
+                    raise LLMGenerationError(f"Invalid JSON from LLM: {e}")
+
+        except openai.OpenAIError as e:
+            raise LLMGenerationError(f"OpenAI API error: {e}")
+        except asyncio.TimeoutError:
+            raise LLMGenerationError("LLM request timed out")
+
+
+# Schema preparation functions (stateless)
+def _prepare_domain_schema() -> Dict[str, Any]:
+    """Prepare domain schema by removing unnecessary parts."""
+    domain_schema = deepcopy(read_schema_file(DOMAIN_SCHEMA_FILE, PACKAGE_NAME, False))
+
+    if not isinstance(domain_schema, dict):
+        raise ValueError("Domain schema is not a dictionary")
+
+    # Remove parts not needed for CALM bots
+    unnecessary_keys = ["intents", "entities", "forms", "config", "session_config"]
+
+    for key in unnecessary_keys:
+        domain_schema["mapping"].pop(key, None)
+
+    # Remove problematic slot mappings
+    slot_mapping = domain_schema["mapping"]["slots"]["mapping"]["regex;([A-Za-z]+)"][
+        "mapping"
+    ]
+    slot_mapping.pop("mappings", None)
+    slot_mapping.pop("validation", None)
+
+    # Add responses schema
+    responses_schema = read_schema_file(RESPONSES_SCHEMA_FILE, PACKAGE_NAME, False)
+    if isinstance(responses_schema, dict):
+        domain_schema["mapping"]["responses"] = responses_schema["schema;responses"]
+    else:
+        raise ValueError("Expected responses schema to be a dictionary.")
+
+    return domain_schema
+
+
+def _prepare_flows_schema() -> Dict[str, Any]:
+    """Prepare flows schema by removing nlu_trigger."""
+    schema_file = str(
+        importlib_resources.files(PACKAGE_NAME).joinpath(FLOWS_SCHEMA_FILE)
+    )
+    flows_schema = deepcopy(read_json_file(schema_file))
+    flows_schema["$defs"]["flow"]["properties"].pop("nlu_trigger", None)
+    return flows_schema
+
+
+# Template functions (stateless with caching)
+_skill_template: Optional[Template] = None
+_helper_template: Optional[Template] = None
+
+
+def get_skill_generation_messages(
+    skill_description: str, project_data: Dict[str, str]
+) -> List[Dict[str, Any]]:
+    """Get messages for skill generation."""
+    global _skill_template
+
+    if _skill_template is None:
+        template_content = importlib.resources.read_text(
+            "rasa.builder",
+            "skill_to_bot_prompt.jinja2",
+        )
+        _skill_template = Template(template_content)
+
+    system_prompt = _skill_template.render(
+        skill_description=skill_description,
+        project_data=project_data,
+    )
+    return [{"role": "system", "content": system_prompt}]
+
+
+# Global service instance
+llm_service = LLMService()

rasa/builder/logging_utils.py

@@ -0,0 +1,265 @@
+"""Logging and Sentry utilities for the builder service."""
+
+import collections
+import logging
+import threading
+import time
+import uuid
+from contextlib import contextmanager
+from typing import Any, Deque, Dict, Generator, List, Mapping, MutableMapping, Optional
+
+import sentry_sdk
+import structlog
+from sanic import Request
+
+from rasa.builder import config
+from rasa.builder.auth import HEADER_USER_ID
+
+structlogger = structlog.get_logger()
+
+# Thread-safe deque for collecting recent logs
+_recent_logs: Deque[str] = collections.deque(maxlen=config.MAX_LOG_ENTRIES)
+_logs_lock = threading.RLock()
+# Thread-local storage for validation logs
+_validation_logs = threading.local()
+
+
+def collecting_logs_processor(
+    logger: Any, log_level: str, event_dict: MutableMapping[str, Any]
+) -> MutableMapping[str, Any]:
+    """Structlog processor that collects recent log entries.
+
+    This processor is thread-safe and maintains a rolling buffer of recent logs.
+    """
+    if log_level != logging.getLevelName(logging.DEBUG).lower():
+        event_message = event_dict.get("event_info") or event_dict.get("event", "")
+        log_entry = f"[{log_level}] {event_message}"
+
+        with _logs_lock:
+            _recent_logs.append(log_entry)
+
+    return event_dict
+
+
+def collecting_validation_logs_processor(
+    logger: Any, method_name: str, event_dict: Dict[str, Any]
+) -> Dict[str, Any]:
+    """Structlog processor that captures validation logs in thread-local storage.
+
+    It's designed to be used with the capture_validation_logs context manager.
+
+    Args:
+        logger: The structlog logger instance
+        method_name: The logging method name (e.g., "error", "warning", "info", "debug")
+        event_dict: The event dictionary containing log data
+
+    Returns:
+        The unmodified event_dict (this processor doesn't modify the log data)
+    """
+    # Only capture logs if we're in a validation context
+    # (logs list exists for this thread)
+    if hasattr(_validation_logs, "logs"):
+        log_entry = {"log_level": method_name, **event_dict}
+        _validation_logs.logs.append(log_entry)
+
+    return event_dict
+
+
+@contextmanager
+def capture_validation_logs() -> Generator[List[Dict[str, Any]], Any, None]:
+    """Context manager to capture validation logs using thread-local storage.
+
+    This context manager temporarily reconfigures structlog to capture all logs
+    during validation and stores them in thread-local storage. It's thread-safe
+    and automatically cleans up after use.
+
+    Yields:
+        A list of captured log entries, each containing the log level and all
+        original log data from the event_dict.
+    """
+    # Temporarily reconfigure structlog to add our capture processor
+    original_processors = structlog.get_config()["processors"]
+    new_processors = [collecting_validation_logs_processor] + original_processors
+    structlog.configure(processors=new_processors)
+
+    # Initialize thread-local logs storage
+    _validation_logs.logs = []
+
+    try:
+        yield _validation_logs.logs
+    finally:
+        # Restore original configuration and clean up thread-local storage
+        structlog.configure(processors=original_processors)
+        if hasattr(_validation_logs, "logs"):
+            delattr(_validation_logs, "logs")
+
+
+def attach_request_id_processor(
+    logger: Any, log_level: str, event_dict: MutableMapping[str, Any]
+) -> MutableMapping[str, Any]:
+    """Structlog processor that attaches the request id to the event dict.
+
+    This processor is thread-safe and maintains a rolling buffer of recent logs.
+    """
+    try:
+        request = Request.get_current()
+        event_dict["correlation_id"] = request.ctx.correlation_id
+        return event_dict
+    except Exception:
+        # there is no request context, so we don't attach the request id
+        return event_dict
+
+
+def get_recent_logs() -> str:
+    """Get recent log entries as a formatted string.
+
+    Returns:
+        Formatted string of recent log entries, one per line.
+    """
+    with _logs_lock:
+        return "\n".join(list(_recent_logs))
+
+
+def clear_recent_logs() -> None:
+    """Clear the recent logs buffer."""
+    with _logs_lock:
+        _recent_logs.clear()
+
+
+def get_log_count() -> int:
+    """Get the current number of log entries."""
+    with _logs_lock:
+        return len(_recent_logs)
+
+
+def _sanitize_headers(headers: Mapping[str, str]) -> Dict[str, Any]:
+    """Remove or redact sensitive headers for safe logging and Sentry context."""
+    lowered = {k.lower(): v for k, v in headers.items()}
+    result: Dict[str, Any] = {}
+    # Safe keepers
+    if "user-agent" in lowered:
+        result["user-agent"] = lowered["user-agent"]
+    if HEADER_USER_ID in lowered:
+        result[HEADER_USER_ID] = lowered[HEADER_USER_ID]
+    # Redact auth info
+    if "authorization" in lowered:
+        auth_val = lowered["authorization"]
+        # Keep only the scheme if present
+        scheme = auth_val.split(" ")[0] if auth_val else ""
+        result["authorization"] = f"{scheme} <redacted>" if scheme else "present"
+    return result
+
+
+def ensure_correlation_id_on_request(request: Any) -> str:
+    """Ensure a correlation id exists on the request and return it."""
+    if not hasattr(request.ctx, "correlation_id") or not request.ctx.correlation_id:
+        request.ctx.correlation_id = uuid.uuid4().hex
+    return request.ctx.correlation_id
+
+
+def extract_request_context() -> Dict[str, Any]:
+    """Extract safe request context for logging / Sentry."""
+    try:
+        request = Request.get_current()
+        headers = getattr(request, "headers", {}) or {}
+        args = getattr(request, "args", {}) or {}
+        json_body = getattr(request, "json", None)
+        content_length = getattr(request, "content_length", None)
+        ctx: Dict[str, Any] = {
+            "method": getattr(request, "method", None),
+            "path": getattr(request, "path", None),
+            "query_args": dict(args) if hasattr(args, "items") else args,
+            "remote_addr": getattr(request, "remote_addr", None),
+            "content_length": content_length,
+            "has_json": json_body is not None,
+            "headers": _sanitize_headers(dict(headers)),
+        }
+        if hasattr(request, "ctx"):
+            ctx["correlation_id"] = ensure_correlation_id_on_request(request)
+            # Common custom fields if present
+            ctx["user_id"] = request.headers.get(HEADER_USER_ID)
+        return ctx
+    except Exception:
+        return {}
+
+
+def capture_exception_with_context(
+    exc: BaseException,
+    event_id: str,
+    extra: Optional[Dict[str, Any]] = None,
+    tags: Optional[Dict[str, str]] = None,
+) -> None:
+    """Capture exception in Sentry and log it with rich context.
+
+    Args:
+        request: Sanic request
+        exc: exception instance
+        event_id: structlog event id
+        extra: additional context to include
+        tags: sentry tags to attach
+    """
+    request_ctx = extract_request_context()
+    if extra is None:
+        extra = {}
+    # Sentry scope
+    try:
+        with sentry_sdk.configure_scope() as scope:
+            scope.set_tag("service", "bot-builder")
+            if tags:
+                for k, v in tags.items():
+                    scope.set_tag(k, v)
+            # Flatten some useful fields as tags
+            if request_ctx.get("path"):
+                scope.set_tag("route", request_ctx["path"])
+            if request_ctx.get("method"):
+                scope.set_tag("method", request_ctx["method"])
+            if request_ctx.get("correlation_id"):
+                scope.set_tag("correlation_id", request_ctx["correlation_id"])
+            user_id = request_ctx.get("user_id")
+            if user_id and hasattr(scope, "set_user"):
+                scope.set_user({"id": str(user_id)})
+            # Context blocks
+            scope.set_context("request", request_ctx)
+            if extra:
+                scope.set_context("extra", extra)
+        sentry_sdk.capture_exception(exc)
+    except Exception:
+        # Never fail the app because Sentry failed
+        pass
+
+    # Structlog error with merged context (avoid dumping huge payloads)
+    structlogger.error(
+        event_id,
+        error=str(exc),
+        **{k: v for k, v in {**request_ctx, **extra}.items() if k not in {"headers"}},
+    )
+
+
+def log_request_start(request: Any) -> float:
+    """Log request start and return start time."""
+    start = time.perf_counter()
+    cid = ensure_correlation_id_on_request(request)
+    ctx = extract_request_context()
+    structlogger.info(
+        "request.received",
+        method=ctx.get("method"),
+        path=ctx.get("path"),
+        remote_addr=ctx.get("remote_addr") or "unknown",
+        correlation_id=cid,
+        user_id=ctx.get("user_id"),
+    )
+    return start
+
+
+def log_request_end(request: Any, response: Any, start: float) -> None:
+    """Log request completion with latency and correlation id."""
+    latency_ms = int((time.perf_counter() - start) * 1000)
+    cid = ensure_correlation_id_on_request(request)
+    structlogger.info(
+        "request.completed",
+        method=getattr(request, "method", None),
+        path=getattr(request, "path", None),
+        status=getattr(response, "status", None),
+        latency_ms=latency_ms,
+        correlation_id=cid,
+    )