Skip to content

OpenRAG is a comprehensive, single package Retrieval-Augmented Generation platform built on Langflow, Docling, and Opensearch.

Python
4.5 KB
Raw Blame
"""Reset workspace onboarding state so the wizard shows again.

Updates ``workspace_config`` (and config.yaml in hybrid/files mode).
Does not delete OpenSearch documents, Langflow flows, or conversations —
use the API ``rollback_onboarding`` endpoint for a full teardown.
"""

from __future__ import annotations

from dataclasses import asdict, dataclass
from typing import Any

from sqlalchemy.ext.asyncio import AsyncSession

from config.config_manager import OnboardingState, config_manager
from config.storage_mode import db_writes_enabled, file_writes_enabled, get_storage_mode
from db.repositories.workspace_config_repo import WorkspaceConfigRepo
from utils.logging_config import get_logger

logger = get_logger(__name__)


@dataclass
class OnboardingResetResult:
    dry_run: bool
    reset_models: bool
    storage_mode: str
    db_updated: bool = False
    yaml_updated: bool = False
    previous_edited: bool | None = None
    previous_step: Any = None

    def as_log_kwargs(self) -> dict[str, Any]:
        return {
            "dry_run": self.dry_run,
            "reset_models": self.reset_models,
            "storage_mode": self.storage_mode,
            "db_updated": self.db_updated,
            "yaml_updated": self.yaml_updated,
            "previous_edited": self.previous_edited,
            "previous_step": self.previous_step,
        }


def _fresh_onboarding_dict() -> dict[str, Any]:
    return asdict(OnboardingState())


def _apply_model_reset(section: dict[str, Any], *, llm: bool) -> dict[str, Any]:
    updated = dict(section or {})
    if llm:
        updated["llm_model"] = ""
        updated["llm_provider"] = "openai"
    else:
        updated["embedding_model"] = ""
        updated["embedding_provider"] = "openai"
    return updated


async def reset_onboarding_in_db(
    session: AsyncSession,
    *,
    reset_models: bool = False,
    dry_run: bool = False,
) -> OnboardingResetResult:
    result = OnboardingResetResult(
        dry_run=dry_run,
        reset_models=reset_models,
        storage_mode=get_storage_mode(),
    )

    repo = WorkspaceConfigRepo(session)
    rows = await repo.list_all()

    meta = dict(rows.get("meta") or {})
    onboarding = dict(rows.get("onboarding") or {})
    result.previous_edited = bool(meta.get("edited", False))
    result.previous_step = onboarding.get("current_step")

    meta["edited"] = False
    fresh_onboarding = _fresh_onboarding_dict()

    if not dry_run:
        await repo.upsert("meta", meta)
        await repo.upsert("onboarding", fresh_onboarding)
        if reset_models:
            await repo.upsert(
                "agent",
                _apply_model_reset(rows.get("agent") or {}, llm=True),
            )
            await repo.upsert(
                "knowledge",
                _apply_model_reset(rows.get("knowledge") or {}, llm=False),
            )
        result.db_updated = True

    logger.info("Onboarding reset in DB", **result.as_log_kwargs())
    return result


def reset_onboarding_yaml(*, reset_models: bool = False, dry_run: bool = False) -> bool:
    """Reset onboarding flags in config.yaml (hybrid / files mode)."""
    if dry_run:
        return False

    config = config_manager.load_config()
    config.edited = False
    config.onboarding = OnboardingState()
    if reset_models:
        config.agent.llm_model = ""
        config.agent.llm_provider = "openai"
        config.knowledge.embedding_model = ""
        config.knowledge.embedding_provider = "openai"

    config_manager._config = config
    return config_manager.save_config_file(config)


async def reset_onboarding(
    session: AsyncSession | None = None,
    *,
    reset_models: bool = False,
    dry_run: bool = False,
) -> OnboardingResetResult:
    """Reset onboarding across the active storage backend(s)."""
    mode = get_storage_mode()
    result = OnboardingResetResult(
        dry_run=dry_run,
        reset_models=reset_models,
        storage_mode=mode,
    )

    if db_writes_enabled():
        if session is None:
            raise ValueError("session is required when DB writes are enabled")
        db_result = await reset_onboarding_in_db(
            session,
            reset_models=reset_models,
            dry_run=dry_run,
        )
        result.db_updated = db_result.db_updated
        result.previous_edited = db_result.previous_edited
        result.previous_step = db_result.previous_step

    if file_writes_enabled():
        result.yaml_updated = reset_onboarding_yaml(
            reset_models=reset_models,
            dry_run=dry_run,
        )

    return result