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

rasa/builder/guardrails/utils.py

@@ -1,31 +1,13 @@
-import asyncio
-from functools import lru_cache
-from typing import TYPE_CHECKING, Dict, List, Optional, Set, Tuple
+from typing import TYPE_CHECKING, Any, Callable, Dict, Optional, Type
 
 import structlog
 
-from rasa.builder.config import (
-    ASSISTANT_HISTORY_GUARDRAIL_PROJECT_ID,
-    COPILOT_HISTORY_GUARDRAIL_PROJECT_ID,
-)
-from rasa.builder.copilot.constants import ROLE_COPILOT, ROLE_USER
-from rasa.builder.copilot.copilot_response_handler import CopilotResponseHandler
-from rasa.builder.copilot.models import (
-    CopilotChatMessage,
-    CopilotContext,
-    GeneratedContent,
-    ResponseCategory,
-)
+from rasa.builder.guardrails.clients import GuardrailsClient, LakeraAIGuardrails
 from rasa.builder.guardrails.models import (
-    GuardrailRequestKey,
-    GuardrailResponse,
+    GuardrailRequest,
     LakeraGuardrailRequest,
 )
-from rasa.builder.llm_service import llm_service
-from rasa.builder.shared.tracker_context import (
-    AssistantConversationTurn,
-    TrackerContext,
-)
+from rasa.shared.constants import ROLE_USER
 
 if TYPE_CHECKING:
     from rasa.builder.guardrails.models import GuardrailType
@@ -64,265 +46,49 @@ def map_lakera_detector_type_to_guardrail_type(
     return GuardrailType.OTHER
 
 
-@lru_cache(maxsize=512)
-def _schedule_guardrails_check(
+def create_guardrail_request(
+    client_type: Type[GuardrailsClient],
     user_text: str,
     hello_rasa_user_id: str,
     hello_rasa_project_id: str,
-    lakera_project_id: str,
-) -> "asyncio.Task[GuardrailResponse]":
-    """Return a cached asyncio.Task that resolves to Lakera's response.
-
-    Args:
-        user_text: The user message text to check for policy violations.
-        hello_rasa_user_id: The user ID for the conversation.
-        hello_rasa_project_id: The project ID for the conversation.
-        lakera_project_id: The Lakera project ID to use for this check.
-
-    Returns:
-        An asyncio Task that resolves to a GuardrailResponse.
-    """
-    structlogger.debug("guardrails.cache_miss", text=user_text)
-
-    loop = asyncio.get_running_loop()
-    request = LakeraGuardrailRequest(
-        lakera_project_id=lakera_project_id,
-        hello_rasa_user_id=hello_rasa_user_id,
-        hello_rasa_project_id=hello_rasa_project_id,
-        messages=[{"role": ROLE_USER, "content": user_text}],
-    )
-
-    return loop.create_task(llm_service.guardrails.send_request(request))
-
-
-async def _detect_flagged_user_indices(
-    items: List[Tuple[int, str]],
-    *,
-    hello_rasa_user_id: Optional[str],
-    hello_rasa_project_id: Optional[str],
-    lakera_project_id: str,
-    log_prefix: str,
-) -> Set[int]:
-    """Run guardrail checks for provided (index, user_text) pairs.
-
-    Args:
-        items: List of tuples containing (index, user_text) to check.
-        hello_rasa_user_id: The user ID for the conversation.
-        hello_rasa_project_id: The project ID for the conversation.
-        lakera_project_id: The Lakera project ID to use for this check.
-        log_prefix: Prefix for logging messages.
-
-    Returns:
-        A set of indices that were flagged by the guardrails.
-    """
-    if not items:
-        return set()
-
-    # 1) Group indices by logical request key (hashable by value)
-    indices_by_key: Dict[GuardrailRequestKey, List[int]] = {}
-    for idx, text in items:
-        key = GuardrailRequestKey(
-            user_text=(text or "").strip(),
-            hello_rasa_user_id=hello_rasa_user_id or "",
-            hello_rasa_project_id=hello_rasa_project_id or "",
-            lakera_project_id=lakera_project_id,
+    **kwargs: Any,
+) -> GuardrailRequest:
+    """Create a guardrail request."""
+
+    def _create_lakera_guardrail_request(
+        user_text: str,
+        hello_rasa_user_id: str,
+        hello_rasa_project_id: str,
+        **kwargs: Any,
+    ) -> LakeraGuardrailRequest:
+        """Create a Lakera guardrail request."""
+        return LakeraGuardrailRequest(
+            hello_rasa_user_id=hello_rasa_user_id,
+            hello_rasa_project_id=hello_rasa_project_id,
+            messages=[{"role": ROLE_USER, "content": user_text}],
+            **kwargs,
         )
-        if not key.user_text:
-            continue
-        indices_by_key.setdefault(key, []).append(idx)
 
-    if not indices_by_key:
-        return set()
+    map_client_to_request: Dict[
+        Type[GuardrailsClient], Callable[..., GuardrailRequest]
+    ] = {
+        LakeraAIGuardrails: _create_lakera_guardrail_request,
+    }
 
-    # 2) Create one task per logical key
-    tasks_by_key: Dict[GuardrailRequestKey, asyncio.Task[GuardrailResponse]] = {}
-    for key in indices_by_key:
-        tasks_by_key[key] = _schedule_guardrails_check(
-            user_text=key.user_text,
-            hello_rasa_user_id=key.hello_rasa_user_id,
-            hello_rasa_project_id=key.hello_rasa_project_id,
-            lakera_project_id=key.lakera_project_id,
+    if client_type in map_client_to_request:
+        return map_client_to_request[client_type](
+            user_text,
+            hello_rasa_user_id,
+            hello_rasa_project_id,
+            **kwargs,
         )
-
-    # 3) Await unique tasks once
-    keys = list(tasks_by_key.keys())
-    tasks = [tasks_by_key[k] for k in keys]
-    responses = await asyncio.gather(*tasks, return_exceptions=True)
-
-    # 4) Map results back to all corresponding indices
-    flagged: Set[int] = set()
-    for key, response in zip(keys, responses):
-        if isinstance(response, Exception):
-            structlogger.warning(f"{log_prefix}.request_failed", error=str(response))
-            continue
-        if response.flagged:
-            flagged.update(indices_by_key.get(key, []))
-
-    return flagged
-
-
-async def check_assistant_chat_for_policy_violations(
-    tracker_context: TrackerContext,
-    hello_rasa_user_id: Optional[str],
-    hello_rasa_project_id: Optional[str],
-) -> TrackerContext:
-    """Return a sanitised TrackerContext with unsafe turns removed.
-
-    Only user messages are moderated – assistant messages are assumed safe.
-    LRU cache is used, so each unique user text is checked once.
-
-    Args:
-        tracker_context: The TrackerContext containing conversation turns.
-        hello_rasa_user_id: The user ID for the conversation.
-        hello_rasa_project_id: The project ID for the conversation.
-
-    Returns:
-        TrackerContext with unsafe turns removed.
-    """
-    # Collect (turn_index, user_text) for all turns with a user message
-    items: List[Tuple[int, str]] = []
-    for idx, turn in enumerate(tracker_context.conversation_turns):
-        user_message = turn.user_message
-        if not user_message:
-            continue
-
-        text = (user_message.text or "").strip()
-        if not text:
-            continue
-
-        items.append((idx, text))
-
-    flagged_turns = await _detect_flagged_user_indices(
-        items,
-        hello_rasa_user_id=hello_rasa_user_id,
-        hello_rasa_project_id=hello_rasa_project_id,
-        lakera_project_id=ASSISTANT_HISTORY_GUARDRAIL_PROJECT_ID,
-        log_prefix="assistant_guardrails",
-    )
-
-    if not flagged_turns:
-        return tracker_context
-
-    structlogger.info(
-        "assistant_guardrails.turns_flagged",
-        count=len(flagged_turns),
-        turn_indices=sorted(flagged_turns),
-    )
-
-    # Build a filtered TrackerContext
-    safe_turns: List[AssistantConversationTurn] = [
-        turn
-        for idx, turn in enumerate(tracker_context.conversation_turns)
-        if idx not in flagged_turns
-    ]
-
-    new_tracker_context = tracker_context.copy(deep=True)
-    new_tracker_context.conversation_turns = safe_turns
-    return new_tracker_context
-
-
-def _annotate_flagged_user_messages(
-    history: List[CopilotChatMessage], flagged_user_indices: Set[int]
-) -> None:
-    """Mark flagged user messages in-place on the original history.
-
-    Args:
-        history: The copilot chat history containing messages.
-        flagged_user_indices: Set of indices of user messages that were flagged.
-    """
-    if not flagged_user_indices:
-        return
-
-    total = len(history)
-    for uidx in flagged_user_indices:
-        if 0 <= uidx < total and history[uidx].role == ROLE_USER:
-            history[
-                uidx
-            ].response_category = ResponseCategory.GUARDRAILS_POLICY_VIOLATION
-
-
-async def check_copilot_chat_for_policy_violations(
-    context: CopilotContext,
-    hello_rasa_user_id: Optional[str],
-    hello_rasa_project_id: Optional[str],
-) -> Optional[GeneratedContent]:
-    """Check the copilot chat history for guardrail policy violations.
-
-    Only user messages are moderated – assistant messages are assumed safe.
-    LRU cache is used, so each unique user text is checked once.
-
-    Args:
-        context: The CopilotContext containing the copilot chat history.
-        hello_rasa_user_id: The user ID for the conversation.
-        hello_rasa_project_id: The project ID for the conversation.
-
-    Returns:
-        Returns a default violation response if the system flags any user message,
-        otherwise return None.
-    """
-    history = context.copilot_chat_history
-
-    # Collect (index, text) for user messages; skip ones already marked as violations
-    items: List[Tuple[int, str]] = []
-    for idx, message in enumerate(history):
-        if message.response_category == ResponseCategory.GUARDRAILS_POLICY_VIOLATION:
-            continue
-        if message.role != ROLE_USER:
-            continue
-        formatted_message = message.to_openai_format()
-        text = (formatted_message.get("content") or "").strip()
-        if not text:
-            continue
-        items.append((idx, text))
-
-    flagged_user_indices = await _detect_flagged_user_indices(
-        items,
-        hello_rasa_user_id=hello_rasa_user_id,
-        hello_rasa_project_id=hello_rasa_project_id,
-        lakera_project_id=COPILOT_HISTORY_GUARDRAIL_PROJECT_ID,
-        log_prefix="copilot_guardrails",
-    )
-
-    _annotate_flagged_user_messages(history, flagged_user_indices)
-
-    if not flagged_user_indices:
-        return None
-
-    # Identify the latest user message index in the current request
-    last_user_idx: Optional[int] = None
-    for i in range(len(history) - 1, -1, -1):
-        if getattr(history[i], "role", None) == ROLE_USER:
-            last_user_idx = i
-            break
-
-    # Remove flagged user messages and their next copilot messages
-    indices_to_remove: Set[int] = set()
-    total = len(history)
-    for uidx in flagged_user_indices:
-        indices_to_remove.add(uidx)
-        next_idx = uidx + 1
-        if (
-            next_idx < total
-            and getattr(history[next_idx], "role", None) == ROLE_COPILOT
-        ):
-            indices_to_remove.add(next_idx)
-
-    # Apply sanitization
-    filtered_history = [
-        msg for i, msg in enumerate(history) if i not in indices_to_remove
-    ]
-    if len(filtered_history) != len(history):
-        structlogger.info(
-            "copilot_guardrails.history_sanitized",
-            removed_indices=sorted(indices_to_remove),
-            removed_messages=len(history) - len(filtered_history),
-            kept_messages=len(filtered_history),
+    else:
+        message = f"Unsupported guardrail client: {type(client_type)}"
+        structlogger.error(
+            "guardrails_policy_checker"
+            ".create_guardrail_request"
+            ".unsupported_guardrail_client",
+            message=message,
+            guardrail_client=client_type,
         )
-        context.copilot_chat_history = filtered_history
-
-    # Block only if the latest user message in this request was flagged
-    if last_user_idx is not None and last_user_idx in flagged_user_indices:
-        return CopilotResponseHandler.respond_to_guardrail_policy_violations()
-
-    # Otherwise proceed (following messages are respected)
-    return None
+        raise ValueError(message)

rasa/builder/jobs.py

@@ -16,10 +16,13 @@ from rasa.builder.models import (
     JobStatusEvent,
 )
 from rasa.builder.project_generator import ProjectGenerator
-from rasa.builder.training_service import train_and_load_agent
+from rasa.builder.training_service import (
+    train_and_load_agent,
+    try_load_existing_agent,
+    update_agent,
+)
 from rasa.builder.validation_service import validate_project
 from rasa.cli.scaffold import ProjectTemplateName
-from rasa.core.channels.studio_chat import StudioChatInput
 
 structlogger = structlog.get_logger()
 
@@ -45,7 +48,6 @@ async def run_prompt_to_bot_job(
         prompt: The natural language prompt for bot generation.
     """
     project_generator: ProjectGenerator = app.ctx.project_generator
-    input_channel: StudioChatInput = app.ctx.input_channel
 
     await push_job_status_event(job, JobStatus.received)
 
@@ -60,10 +62,8 @@ async def run_prompt_to_bot_job(
 
         # 2. Training
         await push_job_status_event(job, JobStatus.training)
-        app.ctx.agent = await train_and_load_agent(
-            project_generator.get_training_input()
-        )
-        input_channel.agent = app.ctx.agent
+        agent = await train_and_load_agent(project_generator.get_training_input())
+        update_agent(agent, app)
         await push_job_status_event(job, JobStatus.train_success)
 
         structlogger.info(
@@ -128,8 +128,7 @@ async def run_template_to_bot_job(
         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
+    project_generator: ProjectGenerator = app.ctx.project_generator
 
     await push_job_status_event(job, JobStatus.received)
 
@@ -142,10 +141,14 @@ async def run_template_to_bot_job(
 
         # 2) Training
         await push_job_status_event(job, JobStatus.training)
-        app.ctx.agent = await train_and_load_agent(
-            project_generator.get_training_input()
-        )
-        input_channel.agent = app.ctx.agent
+        agent = await try_load_existing_agent(project_generator.project_folder)
+        if agent is None:
+            agent = await train_and_load_agent(project_generator.get_training_input())
+        else:
+            structlogger.info(
+                "bot_builder_service.template_to_bot.agent_loaded_from_cache",
+            )
+        update_agent(agent, app)
         await push_job_status_event(job, JobStatus.train_success)
 
         # 3) Done
@@ -204,17 +207,26 @@ async def run_template_to_bot_job(
         job_manager.mark_done(job, error=str(exc))
 
 
-async def run_update_files_job(
+async def run_replace_all_files_job(
     app: "Sanic",
     job: JobInfo,
     bot_files: dict,
 ) -> None:
+    """Run the replace-all-files job in the background.
+
+    This replaces all bot files with the provided files and deletes any files
+    not included in the request (excluding .rasa/ and models/ directories).
+
+    Args:
+        app: The Sanic application instance.
+        job: The job information instance.
+        bot_files: Dictionary of file names to content for replacement.
+    """
     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)
+        project_generator.replace_all_bot_files(bot_files)
 
         # 1. Validating
         await push_job_status_event(job, JobStatus.validating)
@@ -226,8 +238,8 @@ async def run_update_files_job(
 
         # 2. Training
         await push_job_status_event(job, JobStatus.training)
-        app.ctx.agent = await train_and_load_agent(training_input)
-        input_channel.agent = app.ctx.agent
+        agent = await train_and_load_agent(training_input)
+        update_agent(agent, app)
         await push_job_status_event(job, JobStatus.train_success)
 
         await push_job_status_event(job, JobStatus.done)
@@ -238,7 +250,7 @@ async def run_update_files_job(
         if config.VALIDATION_FAIL_ON_WARNINGS:
             log_levels.append("warning")
         structlogger.debug(
-            "update_files_job.validation_error",
+            "replace_all_files_job.validation_error",
             job_id=job.id,
             error=str(exc),
             validation_logs=exc.validation_logs,
@@ -252,7 +264,7 @@ async def run_update_files_job(
 
     except TrainingError as exc:
         structlogger.debug(
-            "update_files_job.train_error",
+            "replace_all_files_job.train_error",
             job_id=job.id,
             error=str(exc),
         )
@@ -262,7 +274,7 @@ async def run_update_files_job(
     except Exception as exc:
         # Capture full traceback for anything truly unexpected
         structlogger.exception(
-            "update_files_job.unexpected_error",
+            "replace_all_files_job.unexpected_error",
             job_id=job.id,
             error=str(exc),
         )

rasa/builder/llm_service.py

@@ -19,7 +19,11 @@ 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.builder.guardrails.clients import (
+    GuardrailsClient,
+    LakeraAIGuardrails,
+)
+from rasa.builder.guardrails.policy_checker import GuardrailsPolicyChecker
 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
@@ -37,7 +41,8 @@ class LLMService:
         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._guardrails: Optional[GuardrailsClient] = None
+        self._guardrails_policy_checker: Optional[GuardrailsPolicyChecker] = None
         self._copilot_response_handler: Optional[CopilotResponseHandler] = None
         self._copilot_internal_message_templates: Optional[Dict[str, str]] = None
 
@@ -77,11 +82,14 @@ class LLMService:
             raise
 
     @property
-    def guardrails(self) -> LakeraAIGuardrails:
+    def guardrails(self) -> Optional[GuardrailsClient]:
         """Get or lazy create guardrails instance."""
-        if self._guardrails is None:
-            self._guardrails = LakeraAIGuardrails()
+        if not config.ENABLE_GUARDRAILS:
+            return None
+        # TODO: Replace with Open Source guardrails implementation once it's ready
         try:
+            if self._guardrails is None:
+                self._guardrails = LakeraAIGuardrails()
             return self._guardrails
         except Exception as e:
             structlogger.error(
@@ -91,6 +99,25 @@ class LLMService:
             )
             raise
 
+    @property
+    def guardrails_policy_checker(self) -> Optional[GuardrailsPolicyChecker]:
+        """Get or lazy create guardrails policy checker instance."""
+        try:
+            if self._guardrails_policy_checker is None and self.guardrails is not None:
+                self._guardrails_policy_checker = GuardrailsPolicyChecker(
+                    self.guardrails
+                )
+            return self._guardrails_policy_checker
+        except Exception as e:
+            structlogger.error(
+                "llm_service.guardrails_policy_checker.error",
+                event_info=(
+                    "LLM Service: Error getting guardrails policy checker instance."
+                ),
+                error=str(e),
+            )
+            raise
+
     @property
     def copilot_internal_message_templates(self) -> Dict[str, str]:
         """Get or lazy load copilot internal message templates."""

rasa/builder/main.py

@@ -22,10 +22,9 @@ from rasa.builder.logging_utils import (
     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.builder.training_service import try_load_existing_agent, update_agent
 from rasa.core.channels.studio_chat import StudioChatInput
-from rasa.model import get_latest_model
+from rasa.model_manager.warm_rasa_process import warmup
 from rasa.server import configure_cors
 from rasa.utils.common import configure_logging_and_warnings
 from rasa.utils.log_utils import configure_structlog
@@ -60,63 +59,6 @@ def setup_input_channel() -> StudioChatInput:
     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."""
 
@@ -157,7 +99,6 @@ def create_app(project_folder: str) -> Sanic:
         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)
@@ -165,6 +106,8 @@ def create_app(project_folder: str) -> Sanic:
     # Set up input channel and store in app context
     app.ctx.input_channel = setup_input_channel()
 
+    update_agent(None, app)
+
     # Register the blueprint
     app.blueprint(bp)
 
@@ -196,7 +139,7 @@ def create_app(project_folder: str) -> Sanic:
         try:
             existing_agent = await try_load_existing_agent(project_folder)
             if existing_agent:
-                app.ctx.agent = existing_agent
+                update_agent(existing_agent, app)
                 structlogger.info("Agent loaded on server startup")
             else:
                 structlogger.info(
@@ -208,6 +151,33 @@ def create_app(project_folder: str) -> Sanic:
     return app
 
 
+def _apply_llm_overrides_from_builder_env() -> None:
+    # Prefer a dedicated builder key, fall back to license if you proxy with it
+    if not config.HELLO_LLM_PROXY_BASE_URL:
+        return
+
+    structlogger.debug(
+        "builder.main.using_llm_proxy", base_url=config.HELLO_LLM_PROXY_BASE_URL
+    )
+
+    if not config.RASA_PRO_LICENSE:
+        structlogger.error(
+            "copilot.proxy_missing_license",
+            event_info=(
+                "HELLO_LLM_PROXY_BASE_URL is set but RASA_PRO_LICENSE is missing."
+            ),
+        )
+        return
+
+    if not os.getenv("OPENAI_API_BASE") and not os.getenv("OPENAI_API_KEY"):
+        base_url = config.HELLO_LLM_PROXY_BASE_URL.rstrip("/")
+        # needed for litellm client
+        os.environ["OPENAI_API_BASE"] = base_url
+        # needed for openai async client
+        os.environ["OPENAI_BASE_URL"] = base_url
+        os.environ["OPENAI_API_KEY"] = config.RASA_PRO_LICENSE
+
+
 def main(project_folder: Optional[str] = None) -> None:
     """Main entry point."""
     try:
@@ -218,6 +188,12 @@ def main(project_folder: Optional[str] = None) -> None:
         rasa.telemetry.initialize_telemetry()
         rasa.telemetry.initialize_error_reporting(private_mode=False)
 
+        _apply_llm_overrides_from_builder_env()
+
+        if config.HELLO_RASA_PROJECT_ID:
+            # ensures long import times for modules are ahead of time
+            warmup()
+
         # working directory needs to be the project folder, e.g.
         # for relative paths (./docs) in a projects config to work
         if not project_folder: