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

rasa/builder/main.py

@@ -0,0 +1,258 @@
+#!/usr/bin/env python3
+"""Main entry point for the prompt-to-bot service."""
+
+import asyncio
+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.agent import Agent, load_agent
+from rasa.core.available_endpoints import AvailableEndpoints
+from rasa.core.channels.studio_chat import StudioChatInput
+from rasa.model import get_latest_model
+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)
+
+
+async def try_load_existing_agent(project_folder: str) -> Optional[Agent]:
+    """Try to load an existing agent from the project's models directory.
+
+    Args:
+        project_folder: Path to the project folder
+
+    Returns:
+        Loaded Agent instance if successful, None otherwise
+    """
+    models_dir = os.path.join(project_folder, "models")
+
+    if not os.path.exists(models_dir) or not os.path.isdir(models_dir):
+        structlogger.debug("No models directory found", models_dir=models_dir)
+        return None
+
+    try:
+        # Find the latest model in the models directory
+        latest_model_path = get_latest_model(models_dir)
+        if not latest_model_path:
+            structlogger.debug(
+                "No models found in models directory", models_dir=models_dir
+            )
+            return None
+
+        structlogger.info(
+            "Found existing model, attempting to load", model_path=latest_model_path
+        )
+
+        # Get available endpoints for agent loading
+        available_endpoints = AvailableEndpoints.get_instance()
+
+        # Load the agent
+        agent = await load_agent(
+            model_path=latest_model_path, endpoints=available_endpoints
+        )
+
+        if agent and agent.is_ready():
+            structlogger.info(
+                "Successfully loaded existing agent", model_path=latest_model_path
+            )
+            return agent
+        else:
+            structlogger.warning(
+                "Agent loaded but not ready", model_path=latest_model_path
+            )
+            return None
+
+    except Exception as e:
+        structlogger.warning(
+            "Failed to load existing agent",
+            models_dir=models_dir,
+            error=str(e),
+            exc_info=True,
+        )
+        return None
+
+
+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: str) -> 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,
+        rasa_version=rasa.__version__,
+    )
+    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/")
+
+    # Register startup event handler for agent loading
+    @app.after_server_start
+    async def load_agent_on_startup(
+        app: Sanic, loop: asyncio.AbstractEventLoop
+    ) -> None:
+        """Load existing agent if available when server starts."""
+        try:
+            existing_agent = await try_load_existing_agent(project_folder)
+            if existing_agent:
+                app.ctx.agent = existing_agent
+                structlogger.info("Agent loaded on server startup")
+            else:
+                structlogger.info(
+                    "No existing agent found, server starting without agent"
+                )
+        except Exception as e:
+            structlogger.warning("Failed to load agent on server startup", error=str(e))
+
+    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 not project_folder:
+            import tempfile
+
+            project_folder = tempfile.mkdtemp(prefix="rasa_builder_")
+
+        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)

rasa/builder/models.py

@@ -0,0 +1,216 @@
+"""Pydantic models for request/response validation."""
+
+import json
+from enum import Enum
+from pathlib import Path
+from typing import Any, Dict, List, Literal, Optional
+
+import structlog
+from pydantic import BaseModel, Field, validator
+
+from rasa.cli.scaffold import ProjectTemplateName
+from rasa.shared.importers.importer import TrainingDataImporter
+
+structlogger = structlog.get_logger()
+
+
+class PromptRequest(BaseModel):
+    """Request model for prompt-to-bot endpoint."""
+
+    prompt: str = Field(
+        ..., min_length=1, max_length=10000, description="The skill description prompt"
+    )
+
+    @validator("prompt")
+    def validate_prompt(cls, v: str) -> str:
+        if not v.strip():
+            raise ValueError("Prompt cannot be empty or whitespace only")
+        return v.strip()
+
+
+class TemplateRequest(BaseModel):
+    """Request model for template-to-bot endpoint."""
+
+    template_name: ProjectTemplateName = Field(
+        ...,
+        description=(
+            f"The template name to use ({ProjectTemplateName.supported_values()})"
+        ),
+    )
+
+    @validator("template_name")
+    def validate_template_name(cls, v: Any) -> Any:
+        if v not in ProjectTemplateName:
+            raise ValueError(
+                f"Template name must be one of {ProjectTemplateName.supported_values()}"
+            )
+        return v
+
+
+class BotDataUpdateRequest(BaseModel):
+    """Request model for bot data updates."""
+
+    domain_yml: Optional[str] = Field(None, alias="domain.yml")
+    flows_yml: Optional[str] = Field(None, alias="flows.yml")
+    config_yml: Optional[str] = Field(None, alias="config.yml")
+
+    class Config:
+        """Config for BotDataUpdateRequest."""
+
+        allow_population_by_field_name = True
+
+
+class BotData(BaseModel):
+    """Data of a running assistant."""
+
+    domain: Dict[str, Any] = Field(..., description="The domain of the assistant.")
+    flows: Dict[str, Any] = Field(..., description="The flows of the assistant.")
+
+
+class AssistantInfo(BaseModel):
+    """Basic information about the loaded assistant."""
+
+    assistant_id: Optional[str] = Field(
+        None,
+        description=(
+            "Assistant identifier coming from `assistant_id` in the model "
+            "metadata (config.yml)."
+        ),
+    )
+
+
+class ApiErrorResponse(BaseModel):
+    """API error response model."""
+
+    status: Literal["error"] = "error"
+    error: str = Field(...)
+    details: Optional[Dict[str, Any]] = Field(None)
+
+
+class ServerSentEventType(str, Enum):
+    progress = "progress"
+    error = "error"
+    _EOF = "_EOF"
+
+
+class ServerSentEvent(BaseModel):
+    """Generic Server-Sent Event payload."""
+
+    event: str = Field(..., description="SSE event name / type")
+    data: Dict[str, Any] = Field(
+        default_factory=dict,
+        description="Arbitrary JSON-serializable payload",
+    )
+
+    @classmethod
+    def build(cls, event: str, data: Any) -> "ServerSentEvent":
+        """General-purpose constructor.
+
+        Args:
+            event: The event name (e.g. "progress", "error").
+            data: Arbitrary key-value pairs to include in the payload.
+
+        Returns:
+            A ServerSentEvent instance with the specified event and data.
+        """
+        return cls(event=event, data=data)
+
+    @classmethod
+    def eof(cls) -> "ServerSentEvent":
+        """Helper that returns the special end-of-stream marker."""
+        return cls(event=ServerSentEventType._EOF.value, data={})
+
+    def format(self) -> str:
+        """Return the text representation used by SSE protocols."""
+        return (
+            f"event: {self.event}\n"
+            f"data: {json.dumps(self.data, separators=(', ', ': '))}\n\n"
+        )
+
+
+class JobStatusEvent(ServerSentEvent):
+    """Job status event with special handling for progress and error states."""
+
+    @classmethod
+    def from_status(
+        cls,
+        status: str,
+        message: Optional[str] = None,
+    ) -> "JobStatusEvent":
+        """Factory for job-status events.
+
+        Args:
+            status: The job status (e.g. "training", "train_success").
+            message: Optional error message for error events.
+
+        Returns:
+            A JobStatusEvent instance with the appropriate event type and data.
+        """
+        event_type = (
+            ServerSentEventType.error if message else ServerSentEventType.progress
+        )
+
+        payload: Dict[str, Any] = {"status": status}
+        if message:
+            payload["message"] = message
+
+        return cls(event=event_type.value, data=payload)
+
+
+class ValidationResult(BaseModel):
+    """Result of validation operation."""
+
+    is_valid: bool = Field(...)
+    errors: Optional[List[str]] = Field(None)
+    warnings: Optional[List[str]] = Field(None)
+
+
+class TrainingResult(BaseModel):
+    """Result of training operation."""
+
+    success: bool = Field(...)
+    model_path: Optional[str] = Field(None)
+    error: Optional[str] = Field(None)
+
+
+BotFiles = Dict[str, Optional[str]]
+
+
+class JobStatus(str, Enum):
+    received = "received"
+    done = "done"
+    error = "error"
+
+    generating = "generating"
+    generation_success = "generation_success"
+    generation_error = "generation_error"
+
+    training = "training"
+    train_success = "train_success"
+    train_error = "train_error"
+
+    validating = "validating"
+    validation_success = "validation_success"
+    validation_error = "validation_error"
+
+
+class JobCreateResponse(BaseModel):
+    job_id: str = Field(...)
+    status: JobStatus = JobStatus.received
+
+
+class TrainingInput(BaseModel):
+    """Input for training a model."""
+
+    model_config = {"arbitrary_types_allowed": True}
+
+    importer: TrainingDataImporter = Field(..., description="Training data importer")
+    endpoints_file: Path = Field(..., description="Path to the endpoints file")
+
+
+class AgentStatus(str, Enum):
+    """Status of the agent."""
+
+    not_loaded = "not_loaded"
+    ready = "ready"
+    not_ready = "not_ready"