rasa-pro 3.13.1a19__py3-none-any.whl → 3.13.1a20__py3-none-any.whl

rasa/builder/jobs.py

@@ -0,0 +1,232 @@
+from typing import Any, Optional
+
+import structlog
+from sanic import Sanic
+
+from rasa.builder.exceptions import (
+    LLMGenerationError,
+    ProjectGenerationError,
+    TrainingError,
+    ValidationError,
+)
+from rasa.builder.job_manager import JobInfo, job_manager
+from rasa.builder.models import (
+    JobStatus,
+    JobStatusEvent,
+)
+from rasa.builder.training_service import train_and_load_agent
+from rasa.builder.validation_service import validate_project
+from rasa.cli.scaffold import ProjectTemplateName
+
+structlogger = structlog.get_logger()
+
+
+async def push_job_status_event(
+    job: JobInfo, status: JobStatus, message: Optional[str] = None
+) -> None:
+    event = JobStatusEvent.from_status(status=status.value, message=message)
+    job.status = status.value
+    await job.put(event)
+
+
+async def run_prompt_to_bot_job(
+    app: Any,
+    job: JobInfo,
+    prompt: str,
+) -> None:
+    """Run the prompt-to-bot job in the background.
+
+    Args:
+        app: The Sanic application instance.
+        job: The job information instance.
+        prompt: The natural language prompt for bot generation.
+    """
+    project_generator = app.ctx.project_generator
+    input_channel = app.ctx.input_channel
+    await push_job_status_event(job, JobStatus.received)
+
+    try:
+        # 1. Generating
+        await push_job_status_event(job, JobStatus.generating)
+        bot_files = await project_generator.generate_project_with_retries(
+            prompt,
+            template=ProjectTemplateName.BASIC,
+        )
+        await push_job_status_event(job, JobStatus.generation_success)
+
+        # 2. Training
+        await push_job_status_event(job, JobStatus.training)
+        importer = project_generator._create_importer()
+        app.ctx.agent = await train_and_load_agent(importer)
+        input_channel.agent = app.ctx.agent
+        await push_job_status_event(job, JobStatus.train_success)
+
+        structlogger.info(
+            "bot_builder_service.prompt_to_bot.success",
+            files_generated=list(bot_files.keys()),
+        )
+        await push_job_status_event(job, JobStatus.done)
+        job_manager.mark_done(job)
+
+    except TrainingError as exc:
+        structlogger.debug(
+            "prompt_to_bot_job.training_error", job_id=job.id, error=str(exc)
+        )
+        await push_job_status_event(job, JobStatus.train_error, message=str(exc))
+        job_manager.mark_done(job, error=str(exc))
+
+    except ValidationError as exc:
+        structlogger.debug(
+            "prompt_to_bot_job.validation_error", job_id=job.id, error=str(exc)
+        )
+        await push_job_status_event(job, JobStatus.validation_error, message=str(exc))
+        job_manager.mark_done(job, error=str(exc))
+
+    except (ProjectGenerationError, LLMGenerationError) as exc:
+        structlogger.debug(
+            "prompt_to_bot_job.generation_error", job_id=job.id, error=str(exc)
+        )
+        await push_job_status_event(job, JobStatus.generation_error, message=str(exc))
+        job_manager.mark_done(job, error=str(exc))
+
+    except Exception as exc:
+        # Capture full traceback
+        structlogger.exception(
+            "prompt_to_bot_job.unexpected_error", job_id=job.id, error=str(exc)
+        )
+        await push_job_status_event(job, JobStatus.error, message=str(exc))
+        job_manager.mark_done(job, error=str(exc))
+
+
+async def run_template_to_bot_job(
+    app: "Sanic",
+    job: JobInfo,
+    template_name: ProjectTemplateName,
+) -> None:
+    """Run the template-to-bot job in the background.
+
+    Args:
+        app: The Sanic application instance.
+        job: The job information instance.
+        template_name: The name of the template to use for bot generation.
+    """
+    project_generator = app.ctx.project_generator
+    input_channel = app.ctx.input_channel
+    await push_job_status_event(job, JobStatus.received)
+
+    try:
+        # 1) Generating
+        await push_job_status_event(job, JobStatus.generating)
+        await project_generator.init_from_template(template_name)
+        bot_files = project_generator.get_bot_files()
+        await push_job_status_event(job, JobStatus.generation_success)
+
+        # 2) Training
+        await push_job_status_event(job, JobStatus.training)
+        importer = project_generator._create_importer()
+        app.ctx.agent = await train_and_load_agent(importer)
+        input_channel.agent = app.ctx.agent
+        await push_job_status_event(job, JobStatus.train_success)
+
+        # 3) Done
+        structlogger.info(
+            "bot_builder_service.template_to_bot.success",
+            files_generated=list(bot_files.keys()),
+        )
+        await push_job_status_event(job, JobStatus.done)
+        job_manager.mark_done(job)
+
+    except TrainingError as exc:
+        structlogger.debug(
+            "template_to_bot_job.training_error",
+            job_id=job.id,
+            error=str(exc),
+        )
+        await push_job_status_event(job, JobStatus.train_error, message=str(exc))
+        job_manager.mark_done(job, error=str(exc))
+
+    except ValidationError as exc:
+        structlogger.debug(
+            "template_to_bot_job.validation_error",
+            job_id=job.id,
+            error=str(exc),
+        )
+        await push_job_status_event(job, JobStatus.validation_error, message=str(exc))
+        job_manager.mark_done(job, error=str(exc))
+
+    except ProjectGenerationError as exc:
+        structlogger.debug(
+            "template_to_bot_job.generation_error",
+            job_id=job.id,
+            error=str(exc),
+        )
+        await push_job_status_event(job, JobStatus.generation_error, message=str(exc))
+        job_manager.mark_done(job, error=str(exc))
+
+    except Exception as exc:
+        # Capture full traceback
+        structlogger.exception(
+            "template_to_bot_job.unexpected_error",
+            job_id=job.id,
+            error=str(exc),
+        )
+        await push_job_status_event(job, JobStatus.error, message=str(exc))
+        job_manager.mark_done(job, error=str(exc))
+
+
+async def run_update_files_job(
+    app: "Sanic",
+    job: JobInfo,
+    bot_files: dict,
+) -> None:
+    project_generator = app.ctx.project_generator
+    input_channel = app.ctx.input_channel
+    await push_job_status_event(job, JobStatus.received)
+
+    try:
+        project_generator.update_bot_files(bot_files)
+
+        # 1. Validating
+        await push_job_status_event(job, JobStatus.validating)
+        importer = project_generator._create_importer()
+        validation_error = await validate_project(importer)
+        if validation_error:
+            raise ValidationError(validation_error)
+        await push_job_status_event(job, JobStatus.validation_success)
+
+        # 2. Training
+        await push_job_status_event(job, JobStatus.training)
+        app.ctx.agent = await train_and_load_agent(importer)
+        input_channel.agent = app.ctx.agent
+        await push_job_status_event(job, JobStatus.train_success)
+
+        await push_job_status_event(job, JobStatus.done)
+        job_manager.mark_done(job)
+
+    except ValidationError as exc:
+        structlogger.debug(
+            "update_files_job.validation_error",
+            job_id=job.id,
+            error=str(exc),
+        )
+        await push_job_status_event(job, JobStatus.validation_error, message=str(exc))
+        job_manager.mark_done(job, error=str(exc))
+
+    except TrainingError as exc:
+        structlogger.debug(
+            "update_files_job.train_error",
+            job_id=job.id,
+            error=str(exc),
+        )
+        await push_job_status_event(job, JobStatus.train_error, message=str(exc))
+        job_manager.mark_done(job, error=str(exc))
+
+    except Exception as exc:
+        # Capture full traceback for anything truly unexpected
+        structlogger.exception(
+            "update_files_job.unexpected_error",
+            job_id=job.id,
+            error=str(exc),
+        )
+        await push_job_status_event(job, JobStatus.error, message=str(exc))
+        job_manager.mark_done(job, error=str(exc))

rasa/builder/llm_service.py

@@ -13,8 +13,10 @@ import structlog
 from jinja2 import Template
 
 from rasa.builder import config
-from rasa.builder.copilot import Copilot
+from rasa.builder.copilot.copilot import Copilot
+from rasa.builder.copilot.copilot_response_handler import CopilotResponseHandler
 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
@@ -31,10 +33,12 @@ class LLMService:
         self._client: Optional[openai.AsyncOpenAI] = None
         self._domain_schema: Optional[Dict[str, Any]] = None
         self._flows_schema: Optional[Dict[str, Any]] = None
-        self._copilot = None
+        self._copilot: Optional[Copilot] = None
+        self._guardrails: Optional[LakeraAIGuardrails] = None
+        self._copilot_response_handler: Optional[CopilotResponseHandler] = None
 
     @property
-    def copilot(self):
+    def copilot(self) -> Copilot:
         """Get or lazy create copilot instance."""
         if self._copilot is None:
             self._copilot = Copilot()
@@ -49,6 +53,52 @@ class LLMService:
             )
             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
+
+    @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."""
@@ -91,7 +141,7 @@ class LLMService:
                         },
                     },
                 }
-                response = await client.chat.completions.create(
+                response = await client.chat.completions.create(  # type: ignore
                     model=config.OPENAI_MODEL,
                     messages=messages,
                     temperature=config.OPENAI_TEMPERATURE,
@@ -135,9 +185,11 @@ def _prepare_domain_schema() -> Dict[str, Any]:
     slot_mapping.pop("validation", None)
 
     # Add responses schema
-    domain_schema["mapping"]["responses"] = read_schema_file(
-        RESPONSES_SCHEMA_FILE, PACKAGE_NAME, False
-    )["schema;responses"]
+    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
 

rasa/builder/logging_utils.py

@@ -1,11 +1,20 @@
-"""Logging utilities for the prompt-to-bot service."""
+"""Logging and Sentry utilities for the builder service."""
 
 import collections
 import logging
 import threading
-from typing import Any, Deque, Dict
+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)
@@ -13,8 +22,8 @@ _logs_lock = threading.RLock()
 
 
 def collecting_logs_processor(
-    logger: Any, log_level: str, event_dict: Dict[str, Any]
-) -> Dict[str, Any]:
+    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.
@@ -29,6 +38,22 @@ def collecting_logs_processor(
     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.
 
@@ -49,3 +74,136 @@ 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

@@ -11,8 +11,14 @@ 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 collecting_logs_processor
+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
@@ -37,7 +43,7 @@ def setup_logging() -> None:
     configure_structlog(
         log_level,
         include_time=True,
-        additional_processors=[collecting_logs_processor],
+        additional_processors=[attach_request_id_processor, collecting_logs_processor],
     )
 
 
@@ -52,23 +58,26 @@ def setup_input_channel() -> StudioChatInput:
 def setup_middleware(app: Sanic) -> None:
     """Setup middleware for request/response processing."""
 
-    @app.middleware("request")
+    @app.middleware("request")  # type: ignore[misc,no-untyped-call]
     async def log_request(request: Request) -> None:
-        structlogger.info(
-            "request.received",
-            method=request.method,
-            path=request.path,
-            remote_addr=request.remote_addr or "unknown",
-        )
+        # store start time on request ctx for later latency calculation
+        request.ctx._start_time = log_request_start(request)
 
-    @app.middleware("response")
+    @app.middleware("response")  # type: ignore[misc,no-untyped-call]
     async def log_response(request: Request, response: HTTPResponse) -> None:
-        structlogger.info(
-            "request.completed",
-            method=request.method,
-            path=request.path,
-            status=response.status,
-        )
+        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:
@@ -116,6 +125,10 @@ def main(project_folder: Optional[str] = None) -> None:
         # Setup logging
         setup_logging()
 
+        # Setup telemetry
+        rasa.telemetry.initialize_telemetry()
+        rasa.telemetry.initialize_error_reporting(private_mode=False)
+
         # Create and configure app
         app = create_app(project_folder)
         register_custom_sanic_error_handler(app)