rasa-pro 3.13.1a18__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

@@ -11,13 +11,12 @@ import importlib_resources
 import openai
 import structlog
 from jinja2 import Template
-from pydantic import ValidationError
 
 from rasa.builder import config
+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.inkeep_document_retrieval import InKeepDocumentRetrieval
-from rasa.builder.llm_context import tracker_as_llm_context
-from rasa.builder.models import Document, LLMBuilderContext, LLMHelperResponse
+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
@@ -34,7 +33,71 @@ 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._helper_schema: Optional[Dict[str, Any]] = None
+        self._copilot: Optional[Copilot] = None
+        self._guardrails: Optional[LakeraAIGuardrails] = None
+        self._copilot_response_handler: Optional[CopilotResponseHandler] = 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
+
+    @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]:
@@ -56,9 +119,6 @@ class LLMService:
         if self._flows_schema is None:
             self._flows_schema = _prepare_flows_schema()
 
-        if self._helper_schema is None:
-            self._helper_schema = _load_helper_schema()
-
     async def generate_rasa_project(
         self, messages: List[Dict[str, Any]]
     ) -> Dict[str, Any]:
@@ -67,24 +127,25 @@ class LLMService:
 
         try:
             async with self._get_client() as client:
-                response = await client.chat.completions.create(
-                    model=config.OPENAI_MODEL,
-                    messages=messages,
-                    temperature=config.OPENAI_TEMPERATURE,
-                    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_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
@@ -101,119 +162,6 @@ class LLMService:
         except asyncio.TimeoutError:
             raise LLMGenerationError("LLM request timed out")
 
-    async def create_helper_messages(
-        self, llm_builder_context: LLMBuilderContext
-    ) -> List[Dict[str, Any]]:
-        """Create helper messages for LLM builder."""
-        # Format chat history for documentation search
-        chat_dump = self._format_chat_dump(llm_builder_context.chat_history)
-
-        # Search documentation
-        documentation_results = await self.search_documentation(chat_dump)
-        formatted_docs = self._format_documentation_results(documentation_results)
-
-        current_conversation = tracker_as_llm_context(llm_builder_context.tracker)
-
-        # Prepare LLM messages
-        system_messages = get_helper_messages(
-            current_conversation,
-            llm_builder_context.bot_logs,
-            llm_builder_context.chat_bot_files,
-            formatted_docs,
-        )
-
-        # Add user messages
-        messages = system_messages.copy()
-        for msg in llm_builder_context.chat_history:
-            messages.append(
-                {
-                    "role": "user" if msg.type == "user" else "assistant",
-                    "content": json.dumps(msg.content)
-                    if isinstance(msg.content, list)
-                    else msg.content,
-                }
-            )
-        return messages
-
-    async def generate_helper_response(
-        self, messages: List[Dict[str, Any]]
-    ) -> LLMHelperResponse:
-        """Generate helper response using OpenAI."""
-        self._prepare_schemas()
-
-        try:
-            async with self._get_client() as client:
-                response = await client.chat.completions.create(
-                    model=config.OPENAI_MODEL,
-                    messages=messages,
-                    response_format={
-                        "type": "json_schema",
-                        "json_schema": {
-                            "name": "llm_helper",
-                            "schema": self._helper_schema,
-                        },
-                    },
-                )
-
-                content = response.choices[0].message.content
-                if not content:
-                    raise LLMGenerationError("Empty response from LLM helper")
-
-                try:
-                    return LLMHelperResponse.model_validate_json(json.loads(content))
-                except json.JSONDecodeError as e:
-                    raise LLMGenerationError(f"Invalid JSON from LLM helper: {e}")
-                except ValidationError as e:
-                    raise LLMGenerationError(f"Invalid JSON from LLM helper: {e}")
-
-        except openai.OpenAIError as e:
-            raise LLMGenerationError(f"OpenAI API error in helper: {e}")
-        except asyncio.TimeoutError:
-            raise LLMGenerationError("LLM helper request timed out")
-
-    async def search_documentation(
-        self, query: str, max_results: Optional[int] = None
-    ) -> List[Document]:
-        """Search documentation using OpenAI vector store."""
-        inkeep_document_retrieval = InKeepDocumentRetrieval()
-        documents = await inkeep_document_retrieval.retrieve_documents(query)
-        return documents
-
-    @staticmethod
-    def _format_chat_dump(messages: List[Dict[str, Any]]) -> str:
-        """Format chat messages for documentation search."""
-        result = ""
-        for message in messages:
-            if message.type == "user":
-                content = (
-                    message.content
-                    if isinstance(message.content, str)
-                    else str(message.content)
-                )
-                result += f"User: {content}\n"
-            else:
-                if isinstance(message.content, list):
-                    for part in message.content:
-                        if part.get("type") == "text":
-                            result += f"Assistant: {part.get('text')}\n"
-                else:
-                    result += f"Assistant: {message.content}\n"
-        return result
-
-    @staticmethod
-    def _format_documentation_results(results: List[Document]) -> str:
-        """Format documentation search results."""
-        if not results:
-            return "<sources>No relevant documentation found.</sources>"
-
-        formatted_results = ""
-        for result in results:
-            formatted_result = f"<result url='{result.url}'>"
-            formatted_result += f"<content>{result.content}</content>"
-            formatted_results += formatted_result + "</result>"
-
-        return f"<sources>{formatted_results}</sources>"
-
 
 # Schema preparation functions (stateless)
 def _prepare_domain_schema() -> Dict[str, Any]:
@@ -237,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
 
@@ -254,15 +204,6 @@ def _prepare_flows_schema() -> Dict[str, Any]:
     return flows_schema
 
 
-def _load_helper_schema() -> Dict[str, Any]:
-    """Load helper schema."""
-    return read_json_file(
-        importlib_resources.files(PACKAGE_NAME).joinpath(
-            "builder/llm-helper-schema.json"
-        )
-    )
-
-
 # Template functions (stateless with caching)
 _skill_template: Optional[Template] = None
 _helper_template: Optional[Template] = None
@@ -288,30 +229,5 @@ def get_skill_generation_messages(
     return [{"role": "system", "content": system_prompt}]
 
 
-def get_helper_messages(
-    current_conversation: str,
-    bot_logs: str,
-    chat_bot_files: Dict[str, str],
-    documentation_results: str,
-) -> List[Dict[str, Any]]:
-    """Get messages for helper response."""
-    global _helper_template
-
-    if _helper_template is None:
-        template_content = importlib.resources.read_text(
-            "rasa.builder",
-            "llm_helper_prompt.jinja2",
-        )
-        _helper_template = Template(template_content)
-
-    system_prompt = _helper_template.render(
-        current_conversation=current_conversation,
-        bot_logs=bot_logs,
-        chat_bot_files=chat_bot_files,
-        documentation_results=documentation_results,
-    )
-    return [{"role": "system", "content": system_prompt}]
-
-
 # Global service instance
 llm_service = LLMService()