rasa-pro 3.14.0.dev3__py3-none-any.whl → 3.14.0.dev5__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,209 @@
+"""Logging and Sentry utilities for the builder service."""
+
+import collections
+import logging
+import threading
+import time
+import uuid
+from typing import Any, Deque, Dict, 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()
+
+
+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 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,
+    )

rasa/builder/main.py

@@ -0,0 +1,174 @@
+#!/usr/bin/env python3
+"""Main entry point for the prompt-to-bot service."""
+
+import logging
+import os
+import sys
+from typing import Optional
+
+import structlog
+from sanic import HTTPResponse, Sanic
+from sanic.request import Request
+from sanic_openapi import openapi3_blueprint
+
+import rasa.core.utils
+import rasa.telemetry
+from rasa.builder import config
+from rasa.builder.logging_utils import (
+    attach_request_id_processor,
+    collecting_logs_processor,
+    log_request_end,
+    log_request_start,
+)
+from rasa.builder.service import bp, setup_project_generator
+from rasa.core.channels.studio_chat import StudioChatInput
+from rasa.server import configure_cors
+from rasa.utils.common import configure_logging_and_warnings
+from rasa.utils.log_utils import configure_structlog
+from rasa.utils.sanic_error_handler import register_custom_sanic_error_handler
+
+structlogger = structlog.get_logger()
+
+
+def setup_logging() -> None:
+    """Setup logging configuration."""
+    log_level = logging.DEBUG
+
+    configure_logging_and_warnings(
+        log_level=log_level,
+        logging_config_file=None,
+        warn_only_once=True,
+        filter_repeated_logs=True,
+    )
+
+    configure_structlog(
+        log_level,
+        include_time=True,
+        additional_processors=[attach_request_id_processor, collecting_logs_processor],
+    )
+
+
+def setup_input_channel() -> StudioChatInput:
+    """Setup the input channel for chat interactions."""
+    studio_chat_credentials = config.get_default_credentials().get(
+        StudioChatInput.name()
+    )
+    return StudioChatInput.from_credentials(credentials=studio_chat_credentials)
+
+
+def setup_middleware(app: Sanic) -> None:
+    """Setup middleware for request/response processing."""
+
+    @app.middleware("request")  # type: ignore[misc,no-untyped-call]
+    async def log_request(request: Request) -> None:
+        # store start time on request ctx for later latency calculation
+        request.ctx._start_time = log_request_start(request)
+
+    @app.middleware("response")  # type: ignore[misc,no-untyped-call]
+    async def log_response(request: Request, response: HTTPResponse) -> None:
+        try:
+            start = getattr(request.ctx, "_start_time", None)
+            if start is None:
+                # If for some reason the request middleware didn't run
+                start = log_request_start(request)
+            # propagate correlation id for clients
+            correlation_id = getattr(request.ctx, "correlation_id", None)
+            if correlation_id:
+                response.headers["X-Correlation-Id"] = correlation_id
+            log_request_end(request, response, start)
+        except Exception:
+            # avoid breaking response path
+            pass
+
+
+def create_app(project_folder: Optional[str] = None) -> Sanic:
+    """Create and configure the Sanic app."""
+    app = Sanic("BotBuilderService")
+
+    # Basic app configuration
+    app.config.REQUEST_TIMEOUT = 60  # 1 minute timeout
+    # Expose auth toggle to app.config so decorators can read it
+    app.config.USE_AUTHENTICATION = True
+
+    structlogger.debug(
+        "builder.main.create_app",
+        project_folder=project_folder,
+        use_authentication=app.config.USE_AUTHENTICATION,
+    )
+    app.ctx.agent = None
+
+    # Set up project generator and store in app context
+    app.ctx.project_generator = setup_project_generator(project_folder)
+
+    # Set up input channel and store in app context
+    app.ctx.input_channel = setup_input_channel()
+
+    # Register the blueprint
+    app.blueprint(bp)
+
+    # OpenAPI docs
+    app.blueprint(openapi3_blueprint)
+    app.config.API_TITLE = "Bot Builder API"
+    app.config.API_VERSION = rasa.__version__
+    app.config.API_DESCRIPTION = (
+        "API for building conversational AI bots from prompts and templates. "
+        "The API allows to change the assistant and retrain it with new data."
+    )
+
+    # Setup middleware
+    setup_middleware(app)
+
+    configure_cors(app, cors_origins=config.CORS_ORIGINS)
+
+    # Register input channel webhooks
+    from rasa.core import channels
+
+    channels.channel.register([app.ctx.input_channel], app, route="/webhooks/")
+
+    return app
+
+
+def main(project_folder: Optional[str] = None) -> None:
+    """Main entry point."""
+    try:
+        # Setup logging
+        setup_logging()
+
+        # Setup telemetry
+        rasa.telemetry.initialize_telemetry()
+        rasa.telemetry.initialize_error_reporting(private_mode=False)
+
+        # working directory needs to be the project folder, e.g.
+        # for relative paths (./docs) in a projects config to work
+        if project_folder:
+            os.chdir(project_folder)
+
+        # Create and configure app
+        app = create_app(project_folder)
+        register_custom_sanic_error_handler(app)
+
+        # Run the service
+        structlogger.info(
+            "service.starting",
+            host=config.BUILDER_SERVER_HOST,
+            port=config.BUILDER_SERVER_PORT,
+        )
+
+        app.run(
+            host=config.BUILDER_SERVER_HOST,
+            port=config.BUILDER_SERVER_PORT,
+            legacy=True,
+            motd=False,
+        )
+
+    except KeyboardInterrupt:
+        print("\nService stopped by user")
+        sys.exit(0)
+    except Exception as e:
+        print(f"Failed to start service: {e}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    project_folder = sys.argv[1] if len(sys.argv) > 1 else None
+    main(project_folder)