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

rasa/builder/llm_service.py

@@ -1,246 +0,0 @@
-"""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

@@ -1,209 +0,0 @@
-"""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

@@ -1,174 +0,0 @@
-#!/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)