rasa-pro 3.13.0a1.dev6__py3-none-any.whl → 3.13.0a1.dev7__py3-none-any.whl

rasa/builder/service.py

@@ -0,0 +1,447 @@
+"""Main service for the prompt-to-bot functionality."""
+
+from typing import Optional
+
+import structlog
+from sanic import Sanic, response
+from sanic.request import Request
+
+from rasa.builder import config
+from rasa.builder.exceptions import (
+    LLMGenerationError,
+    ProjectGenerationError,
+    TrainingError,
+    ValidationError,
+)
+from rasa.builder.llm_service import llm_service
+from rasa.builder.logging_utils import get_recent_logs
+from rasa.builder.models import (
+    ApiErrorResponse,
+    ApiResponse,
+    LLMBuilderContext,
+    LLMBuilderRequest,
+    PromptRequest,
+    ServerSentEvent,
+    TemplateRequest,
+)
+from rasa.builder.project_generator import ProjectGenerator
+from rasa.builder.training_service import train_and_load_agent
+from rasa.builder.validation_service import validate_project
+from rasa.cli.scaffold import ProjectTemplateName
+from rasa.core.channels.studio_chat import StudioChatInput
+from rasa.server import configure_cors
+from rasa.shared.core.trackers import DialogueStateTracker
+
+structlogger = structlog.get_logger()
+
+
+class PromptToBotService:
+    """Main service for prompt-to-bot functionality."""
+
+    def __init__(self, project_folder: Optional[str] = None):
+        """Initialize the service with a project folder for file persistence.
+
+        Args:
+            project_folder: Path to the folder where project files will be stored.
+                           If None, defaults to a temporary directory.
+        """
+        if project_folder is None:
+            import tempfile
+
+            project_folder = tempfile.mkdtemp(prefix="rasa_builder_")
+
+        structlogger.info(
+            "prompt_to_bot.service_initialized", project_folder=project_folder
+        )
+
+        self.project_generator = ProjectGenerator(project_folder)
+
+        self.app = Sanic("PromptToBotService")
+        self.app.config.REQUEST_TIMEOUT = 60  # 1 minute timeout
+        self.app.ctx.agent = None
+        self.input_channel = self.setup_input_channel()
+        self.setup_routes()
+        self.setup_middleware()
+
+        configure_cors(self.app, cors_origins=config.CORS_ORIGINS)
+
+    def setup_input_channel(self) -> 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_routes(self):
+        """Setup all API routes."""
+        # Core endpoints
+        self.app.add_route(
+            self.handle_prompt_to_bot, "/api/prompt-to-bot", methods=["POST"]
+        )
+        self.app.add_route(
+            self.handle_template_to_bot, "/api/template-to-bot", methods=["POST"]
+        )
+        self.app.add_route(self.get_bot_data, "/api/bot-data", methods=["GET"])
+        self.app.add_route(self.update_bot_data, "/api/bot-data", methods=["PUT"])
+        self.app.add_route(self.llm_builder, "/api/llm-builder", methods=["POST"])
+
+        # Health check
+        self.app.add_route(self.health, "/", methods=["GET"])
+
+        # Register input channel webhooks
+        from rasa.core import channels
+
+        channels.channel.register([self.input_channel], self.app, route="/webhooks/")
+
+    def setup_middleware(self):
+        """Setup middleware for request/response processing."""
+
+        @self.app.middleware("request")
+        async def log_request(request):
+            structlogger.info(
+                "request.received",
+                method=request.method,
+                path=request.path,
+                remote_addr=request.remote_addr or "unknown",
+            )
+
+        @self.app.middleware("response")
+        async def log_response(request, response):
+            structlogger.info(
+                "request.completed",
+                method=request.method,
+                path=request.path,
+                status=response.status,
+            )
+
+    async def health(self, request: Request):
+        """Health check endpoint."""
+        return response.json({"status": "ok", "service": "prompt-to-bot"})
+
+    async def handle_prompt_to_bot(self, request: Request):
+        """Handle prompt-to-bot generation requests."""
+        try:
+            # Validate request
+            prompt_data = PromptRequest(**request.json)
+
+            # Generate project with retries
+            bot_files = await self.project_generator.generate_project_with_retries(
+                prompt_data.prompt,
+                template=ProjectTemplateName.PLAIN,
+            )
+
+            # Train and load agent
+            importer = self.project_generator._create_importer()
+            self.app.ctx.agent = await train_and_load_agent(importer)
+
+            # Update input channel with new agent
+            self.input_channel.agent = self.app.ctx.agent
+
+            structlogger.info(
+                "prompt_to_bot.success",
+                client_id=prompt_data.client_id,
+                files_generated=list(bot_files.keys()),
+            )
+
+            return response.json(
+                ApiResponse(
+                    status="success",
+                    message="Bot generated successfully",
+                    data={"bot_data": bot_files},
+                ).model_dump()
+            )
+
+        except ValidationError as e:
+            structlogger.error("prompt_to_bot.validation_error", error=str(e))
+            return response.json(
+                ApiErrorResponse(
+                    error="Validation failed", details={"validation_error": str(e)}
+                ).model_dump(),
+                status=400,
+            )
+
+        except ProjectGenerationError as e:
+            structlogger.error("prompt_to_bot.generation_error", error=str(e))
+            return response.json(
+                ApiErrorResponse(
+                    error="Project generation failed",
+                    details={"attempts": e.attempts, "error": str(e)},
+                ).model_dump(),
+                status=500,
+            )
+
+        except TrainingError as e:
+            structlogger.error("prompt_to_bot.training_error", error=str(e))
+            return response.json(
+                ApiErrorResponse(
+                    error="Model training failed", details={"training_error": str(e)}
+                ).model_dump(),
+                status=500,
+            )
+
+        except LLMGenerationError as e:
+            structlogger.error("prompt_to_bot.llm_error", error=str(e))
+            return response.json(
+                ApiErrorResponse(
+                    error="LLM generation failed", details={"llm_error": str(e)}
+                ).model_dump(),
+                status=502,
+            )
+
+        except Exception as e:
+            structlogger.error("prompt_to_bot.unexpected_error", error=str(e))
+            return response.json(
+                ApiErrorResponse(error="Unexpected error occurred").model_dump(),
+                status=500,
+            )
+
+    async def handle_template_to_bot(self, request: Request):
+        """Handle template-to-bot generation requests."""
+        try:
+            # Validate request
+            template_data = TemplateRequest(**request.json)
+
+            # Generate project with retries
+            self.project_generator.init_from_template(
+                template_data.template_name,
+            )
+            bot_files = self.project_generator.get_bot_files()
+
+            # Train and load agent
+            importer = self.project_generator._create_importer()
+            self.app.ctx.agent = await train_and_load_agent(importer)
+
+            # Update input channel with new agent
+            self.input_channel.agent = self.app.ctx.agent
+
+            structlogger.info(
+                "template_to_bot.success",
+                client_id=template_data.client_id,
+                files_generated=list(bot_files.keys()),
+            )
+
+            return response.json(
+                ApiResponse(
+                    status="success",
+                    message="Bot generated successfully",
+                    data={"bot_data": bot_files},
+                ).model_dump()
+            )
+
+        except ValidationError as e:
+            structlogger.error("template_to_bot.validation_error", error=str(e))
+            return response.json(
+                ApiErrorResponse(
+                    error="Validation failed", details={"validation_error": str(e)}
+                ).model_dump(),
+                status=400,
+            )
+
+        except ProjectGenerationError as e:
+            structlogger.error("template_to_bot.generation_error", error=str(e))
+            return response.json(
+                ApiErrorResponse(
+                    error="Project generation failed",
+                    details={"attempts": e.attempts, "error": str(e)},
+                ).model_dump(),
+                status=500,
+            )
+
+        except TrainingError as e:
+            structlogger.error("template_to_bot.training_error", error=str(e))
+            return response.json(
+                ApiErrorResponse(
+                    error="Model training failed", details={"training_error": str(e)}
+                ).model_dump(),
+                status=500,
+            )
+
+        except LLMGenerationError as e:
+            structlogger.error("template_to_bot.llm_error", error=str(e))
+            return response.json(
+                ApiErrorResponse(
+                    error="LLM generation failed", details={"llm_error": str(e)}
+                ).model_dump(),
+                status=502,
+            )
+
+        except Exception as e:
+            structlogger.error("template_to_bot.unexpected_error", error=str(e))
+            return response.json(
+                ApiErrorResponse(error="Unexpected error occurred").model_dump(),
+                status=500,
+            )
+
+    async def get_bot_data(self, request: Request):
+        """Get current bot data."""
+        bot_files = self.project_generator.get_bot_files()
+        return response.json(
+            ApiResponse(status="success", data={"bot_data": bot_files}).model_dump()
+        )
+
+    async def update_bot_data(self, request: Request):
+        """Update bot data with server-sent events for progress tracking."""
+        sse_response = await request.respond(content_type="text/event-stream")
+
+        try:
+            # 1. Received
+            await self._send_sse_event(
+                sse_response,
+                ServerSentEvent(event="received", data={"status": "received"}),
+            )
+
+            # Update bot files
+            bot_data = request.json
+            self.project_generator.update_bot_files(bot_data)
+
+            # 2. Validating
+            await self._send_sse_event(
+                sse_response,
+                ServerSentEvent(event="validating", data={"status": "validating"}),
+            )
+
+            try:
+                importer = self.project_generator._create_importer()
+                validation_error = await validate_project(importer)
+
+                if validation_error:
+                    raise ValidationError(validation_error)
+
+                await self._send_sse_event(
+                    sse_response,
+                    ServerSentEvent(
+                        event="validation_success",
+                        data={"status": "validation_success"},
+                    ),
+                )
+
+            except ValidationError as e:
+                await self._send_sse_event(
+                    sse_response,
+                    ServerSentEvent(
+                        event="validation_error",
+                        data={"status": "validation_error", "error": str(e)},
+                    ),
+                )
+                await sse_response.eof()
+                return
+
+            # 3. Training
+            await self._send_sse_event(
+                sse_response,
+                ServerSentEvent(event="training", data={"status": "training"}),
+            )
+
+            try:
+                self.app.ctx.agent = await train_and_load_agent(importer)
+                self.input_channel.agent = self.app.ctx.agent
+
+                await self._send_sse_event(
+                    sse_response,
+                    ServerSentEvent(
+                        event="train_success", data={"status": "train_success"}
+                    ),
+                )
+
+            except TrainingError as e:
+                await self._send_sse_event(
+                    sse_response,
+                    ServerSentEvent(
+                        event="train_error",
+                        data={"status": "train_error", "error": str(e)},
+                    ),
+                )
+                await sse_response.eof()
+                return
+
+            # 4. Done
+            await self._send_sse_event(
+                sse_response,
+                ServerSentEvent(
+                    event="done",
+                    data={
+                        "status": "done",
+                        "bot_data": self.project_generator.get_bot_files(),
+                    },
+                ),
+            )
+
+        except Exception as e:
+            await self._send_sse_event(
+                sse_response,
+                ServerSentEvent(
+                    event="error", data={"status": "error", "error": str(e)}
+                ),
+            )
+        finally:
+            await sse_response.eof()
+
+    async def llm_builder(self, request: Request):
+        """Handle LLM builder requests."""
+        try:
+            # Validate request
+            builder_request = LLMBuilderRequest(**request.json)
+
+            # Get current conversation context
+            current_tracker = await self.current_tracker_from_input_channel()
+            bot_logs = get_recent_logs()
+            chat_bot_files = self.project_generator.get_bot_files()
+
+            # create LLM builder context
+            llm_builder_context = LLMBuilderContext(
+                tracker=current_tracker,
+                bot_logs=bot_logs,
+                chat_bot_files=chat_bot_files,
+                chat_history=builder_request.messages,
+            )
+
+            # Generate response
+            messages = await llm_service.create_helper_messages(llm_builder_context)
+            llm_response = await llm_service.generate_helper_response(messages)
+
+            return response.json(llm_response)
+
+        except LLMGenerationError as e:
+            structlogger.error("llm_builder.generation_error", error=str(e))
+            return response.json(
+                ApiErrorResponse(
+                    error="LLM helper generation failed", details={"llm_error": str(e)}
+                ).model_dump(),
+                status=502,
+            )
+
+        except Exception as e:
+            structlogger.error("llm_builder.unexpected_error", error=str(e))
+            return response.json(
+                ApiErrorResponse(error="Unexpected error in LLM builder").model_dump(),
+                status=500,
+            )
+
+    async def current_tracker_from_input_channel(
+        self,
+    ) -> Optional[DialogueStateTracker]:
+        """Generate chat bot context from current conversation."""
+        if self.app.ctx.agent and self.input_channel.latest_tracker_session_id:
+            return await self.app.ctx.agent.tracker_store.retrieve(
+                self.input_channel.latest_tracker_session_id
+            )
+        else:
+            return None
+
+    @staticmethod
+    async def _send_sse_event(sse_response, event: ServerSentEvent):
+        """Send a server-sent event."""
+        await sse_response.send(event.format())
+
+    def run(self):
+        """Run the service."""
+        structlogger.info(
+            "service.starting", host=config.SERVER_HOST, port=config.SERVER_PORT
+        )
+
+        self.app.run(
+            host=config.SERVER_HOST,
+            port=config.SERVER_PORT,
+            legacy=True,
+            motd=False,
+        )

rasa/builder/skill_to_bot_prompt.jinja2

@@ -153,7 +153,12 @@ CALM BOT JSON:
 - Consider error handling and alternative conversation paths
 - Aim for a balance between simplicity and functionality
 
-Now, please generate Rasa CALM flow and domain JSON configuration for the following skill description:
+Now, please generate Rasa CALM flow and domain JSON based on the initial bot data.
+Modify the initial bot data where it makes sense based on the users description
+of the skill (e.g. the initial bot greeting utter_greet).
+
+INITIAL BOT DATA:
+{{project_data|tojson}}
 
 USER_SKILL_DESCRIPTION:
 {{skill_description}}

rasa/builder/training_service.py

@@ -0,0 +1,123 @@
+"""Functions for training and loading Rasa models."""
+
+import tempfile
+
+import structlog
+
+from rasa.builder import config
+from rasa.builder.exceptions import AgentLoadError, TrainingError
+from rasa.core import agent
+from rasa.core.utils import AvailableEndpoints, read_endpoints_from_path
+from rasa.model_training import train
+from rasa.shared.importers.importer import TrainingDataImporter
+from rasa.shared.utils.yaml import dump_obj_as_yaml_to_string
+
+structlogger = structlog.get_logger()
+
+
+async def train_and_load_agent(importer: TrainingDataImporter) -> agent.Agent:
+    """Train a model and load an agent.
+
+    Args:
+        importer: Training data importer with domain, flows, and config
+
+    Returns:
+        Loaded and ready agent
+
+    Raises:
+        TrainingError: If training fails
+        AgentLoadError: If agent loading fails
+    """
+    try:
+        # Setup endpoints for training validation
+        await _setup_endpoints()
+
+        # Train the model
+        training_result = await _train_model(importer)
+
+        # Load the agent
+        agent_instance = await _load_agent(training_result.model)
+
+        # Verify agent is ready
+        if not agent_instance.is_ready():
+            raise AgentLoadError("Agent failed to load properly - model is not ready")
+
+        structlogger.info("training.agent_ready", model_path=training_result.model)
+
+        return agent_instance
+
+    except (TrainingError, AgentLoadError):
+        raise
+    except Exception as e:
+        raise TrainingError(f"Unexpected error during training: {e}")
+
+
+async def _setup_endpoints():
+    """Setup endpoints configuration for training."""
+    try:
+        with tempfile.NamedTemporaryFile(
+            mode="w", suffix=".yml", delete=False
+        ) as temp_file:
+            endpoints_yaml = dump_obj_as_yaml_to_string(config.get_default_endpoints())
+            temp_file.write(endpoints_yaml)
+            temp_file.flush()
+
+            # Reset and load endpoints
+            AvailableEndpoints.reset_instance()
+            read_endpoints_from_path(temp_file.name)
+
+            structlogger.debug("training.endpoints_setup", temp_file=temp_file.name)
+
+    except Exception as e:
+        raise TrainingError(f"Failed to setup endpoints: {e}")
+
+
+async def _train_model(importer: TrainingDataImporter):
+    """Train the Rasa model."""
+    try:
+        structlogger.info("training.started")
+
+        training_result = await train(
+            domain="",
+            config="",
+            training_files=None,
+            file_importer=importer,
+        )
+
+        if not training_result or not training_result.model:
+            raise TrainingError("Training completed but no model was produced")
+
+        structlogger.info("training.completed", model_path=training_result.model)
+
+        return training_result
+
+    except Exception as e:
+        raise TrainingError(f"Model training failed: {e}")
+
+
+async def _load_agent(model_path: str) -> agent.Agent:
+    """Load the trained agent."""
+    try:
+        structlogger.info("training.loading_agent", model_path=model_path)
+
+        available_endpoints = AvailableEndpoints.get_instance()
+        if available_endpoints is None:
+            raise AgentLoadError("No endpoints available for agent loading")
+
+        agent_instance = await agent.load_agent(
+            model_path=model_path,
+            remote_storage=None,
+            endpoints=available_endpoints,
+        )
+
+        if agent_instance is None:
+            raise AgentLoadError("Agent loading returned None")
+
+        structlogger.info("training.agent_loaded", model_path=model_path)
+
+        return agent_instance
+
+    except AgentLoadError:
+        raise
+    except Exception as e:
+        raise AgentLoadError(f"Failed to load agent: {e}")

rasa/builder/validation_service.py

@@ -0,0 +1,79 @@
+"""Functions for validating Rasa projects."""
+
+import sys
+from contextlib import contextmanager
+from typing import Optional
+
+import structlog
+from structlog.testing import capture_logs
+
+from rasa.builder import config
+from rasa.builder.exceptions import ValidationError
+from rasa.cli.utils import validate_files
+from rasa.shared.importers.importer import TrainingDataImporter
+
+structlogger = structlog.get_logger()
+
+
+@contextmanager
+def _mock_sys_exit():
+    """Context manager to prevent sys.exit from being called during validation."""
+    was_sys_exit_called = {"value": False}
+
+    def sys_exit_mock(code: int = 0):
+        was_sys_exit_called["value"] = True
+
+    original_exit = sys.exit
+    sys.exit = sys_exit_mock
+
+    try:
+        yield was_sys_exit_called
+    finally:
+        sys.exit = original_exit
+
+
+async def validate_project(importer: TrainingDataImporter) -> Optional[str]:
+    """Validate a Rasa project.
+
+    Args:
+        importer: Training data importer with domain, flows, and config
+
+    Returns:
+        None if validation passes, error message if validation fails.
+
+    Raises:
+        ValidationError: If validation fails
+    """
+    try:
+        with _mock_sys_exit() as exit_tracker:
+            with capture_logs() as cap_logs:
+                validate_files(
+                    fail_on_warnings=config.VALIDATION_FAIL_ON_WARNINGS,
+                    max_history=config.VALIDATION_MAX_HISTORY,
+                    importer=importer,
+                )
+
+            if exit_tracker["value"]:
+                error_logs = [
+                    log for log in cap_logs if log.get("log_level") != "debug"
+                ]
+                structlogger.error(
+                    "validation.failed.sys_exit",
+                    error_logs=error_logs,
+                )
+                raise ValidationError(
+                    "Validation failed with sys.exit", validation_logs=error_logs
+                )
+
+            structlogger.info("validation.success")
+            return None
+
+    except ValidationError:
+        raise
+    except Exception as e:
+        error_msg = f"Validation failed with exception: {e}"
+        structlogger.error(
+            "validation.failed.exception",
+            error=str(e),
+        )
+        raise ValidationError(error_msg)

rasa/cli/project_templates/finance/config.yml

@@ -0,0 +1,17 @@
+# The config recipe.
+recipe: default.v1
+
+# The assistant project unique identifier
+# This default value must be replaced with a unique assistant name within your deployment
+assistant_id: placeholder_default
+
+language: en
+pipeline:
+- name: CompactLLMCommandGenerator
+  llm:
+    model_group: openai-gpt-4o
+
+# Configuration for Rasa Core.
+policies:
+- name: FlowPolicy
+- name: IntentlessPolicy