OpenRAG 0.6.0.dev17__py3-none-any.whl → 0.6.0.dev19__py3-none-any.whl

api/flows.py

@@ -1,18 +1,26 @@
 """Reset Flow API endpoints"""
+
 from typing import Literal
 
 from fastapi import Depends
 from fastapi.responses import JSONResponse
-from utils.logging_config import get_logger
+from pydantic import BaseModel
 
-from dependencies import get_flows_service, get_current_user, require_permission
+from dependencies import get_flows_service, require_permission
 from session_manager import User
+from utils.logging_config import get_logger
 
 logger = get_logger(__name__)
 
 FlowType = Literal["nudges", "retrieval", "ingest"]
 
 
+def _is_oss_mode() -> bool:
+    from config.settings import IBM_AUTH_ENABLED, is_dev_ibm_cos_enabled
+
+    return not (IBM_AUTH_ENABLED or is_dev_ibm_cos_enabled())
+
+
 async def reset_flow_endpoint(
     flow_type: str,
     flows_service=Depends(get_flows_service),
@@ -23,27 +31,19 @@ async def reset_flow_endpoint(
         return JSONResponse(
             {
                 "success": False,
-                "error": "Invalid flow type. Must be 'nudges', 'retrieval', or 'ingest'"
+                "error": "Invalid flow type. Must be 'nudges', 'retrieval', or 'ingest'",
             },
-            status_code=400
+            status_code=400,
         )
 
     try:
         result = await flows_service.reset_langflow_flow(flow_type)
 
         if result.get("success"):
-            logger.info(
-                "Flow reset successful",
-                flow_type=flow_type,
-                flow_id=result.get("flow_id")
-            )
+            logger.info("Flow reset successful", flow_type=flow_type, flow_id=result.get("flow_id"))
             return JSONResponse(result, status_code=200)
         else:
-            logger.error(
-                "Flow reset failed",
-                flow_type=flow_type,
-                error=result.get("error")
-            )
+            logger.error("Flow reset failed", flow_type=flow_type, error=result.get("error"))
             return JSONResponse(result, status_code=500)
 
     except ValueError as e:
@@ -51,7 +51,67 @@ async def reset_flow_endpoint(
         return JSONResponse({"success": False, "error": str(e)}, status_code=400)
     except Exception as e:
         logger.error("Unexpected error in flow reset", error=str(e))
+        return JSONResponse({"success": False, "error": "Internal server error"}, status_code=500)
+
+
+class BulkUpdateFlowsRequest(BaseModel):
+    flow_types: list[str]
+    backup_custom: bool = True
+
+
+async def get_flows_updates_endpoint(
+    flows_service=Depends(get_flows_service),
+    user: User = Depends(require_permission("flows:read")),
+):
+    """Get available updates for core flows"""
+    if not _is_oss_mode():
+        return JSONResponse({"success": True, "updates": []}, status_code=200)
+    try:
+        user_id = getattr(user, "db_user_id", None) or getattr(user, "user_id", None)
+        updates = await flows_service.get_flows_updates_available(user_id=user_id)
+        return JSONResponse({"success": True, "updates": updates}, status_code=200)
+    except Exception as e:
+        logger.error("Error getting flow updates", error=str(e))
+        return JSONResponse({"success": False, "error": "Internal server error"}, status_code=500)
+
+
+async def bulk_update_flows_endpoint(
+    request: BulkUpdateFlowsRequest,
+    flows_service=Depends(get_flows_service),
+    user: User = Depends(require_permission("flows:edit")),
+):
+    """Bulk update multiple flows and optionally backup custom flows"""
+    if not _is_oss_mode():
         return JSONResponse(
-            {"success": False, "error": f"Internal server error: {str(e)}"},
-            status_code=500
+            {"success": False, "error": "Flow updates are only available in OSS mode"},
+            status_code=403,
         )
+    try:
+        results = await flows_service.bulk_update_flows(request.flow_types, request.backup_custom)
+        overall_success = all(r.get("success", False) for r in results)
+        return JSONResponse({"success": overall_success, "results": results}, status_code=200)
+    except Exception as e:
+        logger.error("Error bulk updating flows", error=str(e))
+        return JSONResponse({"success": False, "error": "Internal server error"}, status_code=500)
+
+
+class DismissFlowsUpdateRequest(BaseModel):
+    flow_types: list[str] | None = None
+
+
+async def dismiss_flows_update_endpoint(
+    request: DismissFlowsUpdateRequest | None = None,
+    flows_service=Depends(get_flows_service),
+    user: User = Depends(require_permission("flows:read")),
+):
+    """Dismiss available flow update notifications ephemerally in backend memory"""
+    if not _is_oss_mode():
+        return JSONResponse({"success": True}, status_code=200)
+    try:
+        flow_types = request.flow_types if request else None
+        user_id = getattr(user, "db_user_id", None) or getattr(user, "user_id", None)
+        flows_service.dismiss_flows_updates(flow_types, user_id=user_id)
+        return JSONResponse({"success": True}, status_code=200)
+    except Exception as e:
+        logger.error("Error dismissing flow updates", error=str(e))
+        return JSONResponse({"success": False, "error": "Internal server error"}, status_code=500)

app/routes/internal.py

@@ -426,6 +426,26 @@ def register_internal_routes(app: FastAPI):
         tags=["internal"],
     )
 
+    # Flow updates endpoints
+    app.add_api_route(
+        "/settings/flows/updates-available",
+        flows.get_flows_updates_endpoint,
+        methods=["GET"],
+        tags=["internal"],
+    )
+    app.add_api_route(
+        "/settings/flows/update",
+        flows.bulk_update_flows_endpoint,
+        methods=["POST"],
+        tags=["internal"],
+    )
+    app.add_api_route(
+        "/settings/flows/dismiss-update",
+        flows.dismiss_flows_update_endpoint,
+        methods=["POST"],
+        tags=["internal"],
+    )
+
     # Router upload ingest endpoint
     app.add_api_route(
         "/router/upload_ingest",

{openrag-0.6.0.dev17.dist-info → openrag-0.6.0.dev19.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openrag
-Version: 0.6.0.dev17
+Version: 0.6.0.dev19
 Summary: OpenRAG is a comprehensive Retrieval-Augmented Generation platform that enables intelligent document search and AI-powered conversations.
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console

{openrag-0.6.0.dev17.dist-info → openrag-0.6.0.dev19.dist-info}/RECORD

@@ -13,7 +13,7 @@ api/connectors.py,sha256=XgNnPjBIB-FGlZ0krEPbXen017BFbS-1rDzpbpeMJg4,103927
 api/docling.py,sha256=PKdLaunKpSB3PaIheogbbRSTPdpGQDV7jc1HuD3d2J8,2430
 api/documents.py,sha256=R3IfnpGzaE73MJxE5kREJRCX6JmTEyFQGNjF3ib5fWk,11841
 api/files.py,sha256=TMxR-NG-e9BLaZccN_bE3uP-CEbdZWThPfKTHvgG6E4,3626
-api/flows.py,sha256=FklETisPSjNTjAkTbF9Jl9Wn17D_Cy78rPN_Dv3D9SI,1864
+api/flows.py,sha256=9dEUSEdoxo4tBBGG0IJVqFDj1SbO1pCrv5nCcliE70o,4592
 api/health.py,sha256=pAEEVl9uVG4zcoR0ZqL_zPfDLz4ficHtALcpzOXjgDI,3102
 api/ingest_preview.py,sha256=mffMLdBuzc--JT8gHvxfRDQcWoWRK5vVQg8uljLNn6o,2431
 api/keys.py,sha256=cPocE-ocfbtSWf3YEvMTHZgrxUcLJIm_7Pex6UVggwY,3477
@@ -51,7 +51,7 @@ app/lifespan.py,sha256=3KJ5pSAg_rILTJrzojFVS9ULJE0D0SZL74-S7fA4UVc,18556
 app/middleware.py,sha256=iMl8TP7XzS8UWB1ZKnjPhAPlbQHWTUXZ2e-Y_evSUNI,2334
 app/router_app.py,sha256=pOxCVnsakUgBIxs42UeE94EJ5peCNRYTP7jk6Eo7on0,5873
 app/routes/__init__.py,sha256=QESovwz429ht1sXMHL1ciQKZOgxCcvuYgLMjoDtxyDA,698
-app/routes/internal.py,sha256=8Ix0PYhH7Bu3NlPAF0dDwD1KH08pIp_HqfsRpHUGuEQ,14094
+app/routes/internal.py,sha256=DjDdYaDs1cPjwGsyUWxRvznMnLrqxmmJznupceJ714U,14619
 app/routes/mcp.py,sha256=JF_JEy6ATnraACeQFk4KDIuaT9LkVSZqzvabHkL51xQ,1159
 app/routes/public_v1.py,sha256=qEzuSIPwXR5FrqaZ0lqOjYqDxH2knqsJyW6L7t0mZak,3406
 auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -128,7 +128,7 @@ models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 models/processors.py,sha256=F0LOVNOOrDS9zCfb-piYf3uRYawiPbmNGO2Da4g6G4I,70039
 models/tasks.py,sha256=BByR2xDl4zqvbCbTGgBC3aChJ_uJoRpHy0TTJrvW5Dc,3152
 models/url.py,sha256=KMleXhlwd3W59axcubMJxIEtHpyBQTvfxkycc-o0kOY,5601
-openrag-0.6.0.dev17.dist-info/licenses/LICENSE,sha256=jWcnPXkUxEinX60Yn-_zjsY9i84vz2QSb0fi53djOkg,11334
+openrag-0.6.0.dev19.dist-info/licenses/LICENSE,sha256=jWcnPXkUxEinX60Yn-_zjsY9i84vz2QSb0fi53djOkg,11334
 services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 services/api_key_service.py,sha256=m04jVSJyDqIl-NgNROKLIfy4QYArZxlvz_WkjqQK7TA,13269
 services/auth_service.py,sha256=qxg5Mj1KvR23dBaZnwe2gjQia5DqvNNi7VQCkkKxq8k,23794
@@ -145,7 +145,7 @@ services/docling_service.py,sha256=C9nXzg4eRsmnjS0kv3SH1MliNqL87cPr6cgbhG8hjKs,1
 services/document_index_writer.py,sha256=204buyb7bHBKciuci3MGF-Q8_bI8SiLMOfuje9BnsE0,12270
 services/document_service.py,sha256=ObGyfDgCdQsJkFiFUoN34yqkjCJyy-6aSvxqAqjfXEw,7604
 services/file_service.py,sha256=aBNwMUTsZqRAsg31IBRlbDMHNZkP9LsUJM6_IEgesVM,8701
-services/flows_service.py,sha256=idV4CmoEQn2zX-Jt-xrTUc4osojnR9AG9GlDKXgbHzs,59891
+services/flows_service.py,sha256=vdr-chLE7VkhxqqIWBzXb7vTA3SaJL4Qen0gfVaiS30,68434
 services/group_acl_service.py,sha256=_Pt1vf8SAgxKuaqnnu4pJ_G2MzyV8czmNBXflkwIg6A,4170
 services/ingest_preview_service.py,sha256=BfH054zIQ_osYnr8rSLs_CW-zDFDsYLuXXK26jIlwi0,6238
 services/knowledge_filter_service.py,sha256=4SXHaFfMJzAZGMjAU8qpdh4H_X3cEnyJp0ijyL9WAiE,15495
@@ -159,7 +159,7 @@ services/onboarding_reset.py,sha256=LiIsmK5mnj4SbGAtma8Hsc6U-I3WjWdsoDeK_cPOtIo,
 services/rbac_service.py,sha256=6lfthiLIRQEk-ahDeiDg_eNDbDyrXNHShfb4qxfirSM,4962
 services/search_service.py,sha256=Qu9cAZTYChuy-L47N1z04HHGI43VIJFqemUdcAC-ZMg,30354
 services/session_ownership_service.py,sha256=RHM2N7n9bETNqOpqXrgEK3F54XHJn2AkoMcXJoBzrEM,9868
-services/startup_orchestrator.py,sha256=hGpXAdfRdnhgi2vt30griDLKZ50thvhoviMF_RChDUo,9247
+services/startup_orchestrator.py,sha256=iLkoPHXyOIB4mFzTapF6viMntSSb-PEJkxRXhk6VY-0,7385
 services/task_service.py,sha256=wnvmd9MEYl_BDWUqmEtjmN08Iik1ANaZrJYyp71lqNA,64551
 services/user_service.py,sha256=KsqQN0qPSwxQsBUBkIxE60TDJNveaDk-5rhQE9bN2Fs,11993
 services/workspace_config_service.py,sha256=Ij-fvy0zd3OSsML4ZwG4WG-QmOuxLWcCf9f3HvtD6iY,16544
@@ -240,8 +240,8 @@ utils/telemetry/__init__.py,sha256=xoStY8hoYWnVe0B_jNthSdzRb7AxCT0rhM8ba9Q0Obg,2
 utils/telemetry/category.py,sha256=wei3V5WyUaiadYjEE5s0ys9PY0TjnebIvTykQU0P_2k,1114
 utils/telemetry/client.py,sha256=RhjW1a27w7W6gHt9X7AxdRPdZGmCEQDPskkxj5nsuiQ,12500
 utils/telemetry/message_id.py,sha256=05CvlKW_LaD00INxd3WV8uXBZ9f_5Cvy-jAyOPmpxTk,9600
-openrag-0.6.0.dev17.dist-info/METADATA,sha256=BGDTqTDPIuXkze9ZxCunCjYk9m4lkGeSDT9zz2-i7oU,8728
-openrag-0.6.0.dev17.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
-openrag-0.6.0.dev17.dist-info/entry_points.txt,sha256=ArKNHB63I3K8vynNkogvZOLmmQFpIsHDL7MvreCmju4,45
-openrag-0.6.0.dev17.dist-info/top_level.txt,sha256=TpFyXTBO-cpphRZHx7Vgwgzg4KmPXwNkkfOo93D5qOk,132
-openrag-0.6.0.dev17.dist-info/RECORD,,
+openrag-0.6.0.dev19.dist-info/METADATA,sha256=CF2Z-QYMINwAljaYaWpYsUO56NM-ILJqbMwPuzVT_YA,8728
+openrag-0.6.0.dev19.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+openrag-0.6.0.dev19.dist-info/entry_points.txt,sha256=ArKNHB63I3K8vynNkogvZOLmmQFpIsHDL7MvreCmju4,45
+openrag-0.6.0.dev19.dist-info/top_level.txt,sha256=TpFyXTBO-cpphRZHx7Vgwgzg4KmPXwNkkfOo93D5qOk,132
+openrag-0.6.0.dev19.dist-info/RECORD,,

services/flows_service.py

@@ -1,7 +1,7 @@
 import asyncio
 import json
 import os
-from datetime import datetime
+from datetime import UTC, datetime
 from typing import Any
 
 from cachetools import LRUCache
@@ -25,6 +25,48 @@ logger = get_logger(__name__)
 
 
 class FlowsService:
+    def __init__(self) -> None:
+        # Ephemeral dict of dismissed flow update notifications per user_id
+        self._dismissed_updates: dict[str, set[str]] = {}
+        # Cache for flow file mappings to avoid repeated filesystem scans
+        self._flow_file_cache: dict[str, str] = {}
+        # Semaphores to prevent race conditions when updating the same flow concurrently
+        self._flow_locks = LRUCache(maxsize=128)
+        self._lock_creation_lock = asyncio.Lock()
+        # Cache for enabled models to avoid redundant API calls
+        self._enabled_models_cache: dict[str, Any] | None = None
+        self._enabled_models_cache_time: datetime | None = None
+        self._enabled_models_cache_ttl = 60  # seconds
+        self._enabled_models_lock = asyncio.Lock()
+        # Cache for available custom flow updates
+        self._custom_updates_cache: list[dict[str, Any]] | None = None
+
+    def dismiss_flows_updates(
+        self, flow_types: list[str] | None = None, user_id: str | None = None
+    ) -> None:
+        """Dismiss flow update notifications ephemerally in backend memory per user."""
+        if not hasattr(self, "_dismissed_updates") or not isinstance(self._dismissed_updates, dict):
+            self._dismissed_updates = {}
+        target_user = user_id or "default"
+        if target_user not in self._dismissed_updates:
+            self._dismissed_updates[target_user] = set()
+
+        if flow_types:
+            self._dismissed_updates[target_user].update(flow_types)
+        else:
+            self._dismissed_updates[target_user].update(
+                ["nudges", "retrieval", "ingest", "url_ingest"]
+            )
+
+    def clear_dismissed_update(self, flow_type: str, user_id: str | None = None):
+        if hasattr(self, "_dismissed_updates") and isinstance(self._dismissed_updates, dict):
+            if user_id:
+                if user_id in self._dismissed_updates:
+                    self._dismissed_updates[user_id].discard(flow_type)
+            else:
+                for user_set in self._dismissed_updates.values():
+                    user_set.discard(flow_type)
+
     async def resolve_ollama_url(self, endpoint: str, force_refresh: bool = False) -> str:
         """Find the correct Ollama URL by probing candidates via Langflow's validate-provider API."""
         from config.config_manager import config_manager
@@ -87,18 +129,6 @@ class FlowsService:
 
         return resolved_url
 
-    def __init__(self):
-        # Cache for flow file mappings to avoid repeated filesystem scans
-        self._flow_file_cache = {}
-        # Semaphores to prevent race conditions when updating the same flow concurrently
-        self._flow_locks = LRUCache(maxsize=128)
-        self._lock_creation_lock = asyncio.Lock()
-        # Cache for enabled models to avoid redundant API calls
-        self._enabled_models_cache = None
-        self._enabled_models_cache_time = None
-        self._enabled_models_cache_ttl = 60  # seconds
-        self._enabled_models_lock = asyncio.Lock()
-
     async def _get_flow_lock(self, flow_id: str) -> asyncio.Lock:
         """Get or create an asyncio.Lock for a specific flow ID"""
         async with self._lock_creation_lock:
@@ -305,8 +335,12 @@ class FlowsService:
         for result in results:
             if not result:
                 continue
-            backup_results[result["type"]].append(result["data"])
-            if result["type"] == "failed":
+            res_type = result.get("type")
+            if res_type in ("backed_up", "skipped", "failed"):
+                target_list = backup_results[res_type]
+                if isinstance(target_list, list):
+                    target_list.append(result.get("data"))
+            if res_type == "failed":
                 backup_results["success"] = False
 
         logger.info(
@@ -328,7 +362,7 @@ class FlowsService:
 
         return backup_results
 
-    async def _backup_flow(self, flow_id: str, flow_type: str, flow_data: dict = None):
+    async def _backup_flow(self, flow_id: str, flow_type: str, flow_data: dict | None = None):
         """
         Backup a single flow to the backup folder.
 
@@ -435,19 +469,7 @@ class FlowsService:
         logger.warning(f"Flow with ID {flow_id} not found in flows directory")
         return None
 
-    async def reset_langflow_flow(self, flow_type: str):
-        """Reset a Langflow flow by uploading the corresponding JSON file
-
-        Args:
-            flow_type: Either 'nudges', 'retrieval', or 'ingest'
-
-        Returns:
-            dict: Success/error response
-        """
-        if not LANGFLOW_URL:
-            raise ValueError("LANGFLOW_URL environment variable is required")
-
-        # Determine flow ID based on type
+    def _get_flow_id_by_type(self, flow_type: str) -> str:
         if flow_type == "nudges":
             flow_id = NUDGES_FLOW_ID
         elif flow_type == "retrieval":
@@ -460,9 +482,64 @@ class FlowsService:
             raise ValueError(
                 "flow_type must be either 'nudges', 'retrieval', 'ingest', or 'url_ingest'"
             )
-
         if not flow_id:
             raise ValueError(f"Flow ID not configured for flow_type '{flow_type}'")
+        return flow_id
+
+    async def reset_langflow_flow(self, flow_type: str):
+        """Reset a Langflow flow by uploading the corresponding JSON file
+
+        Args:
+            flow_type: Either 'nudges', 'retrieval', 'ingest', or 'url_ingest'
+
+        Returns:
+            dict: Success/error response
+        """
+        flow_id = self._get_flow_id_by_type(flow_type)
+        flow_lock = await self._get_flow_lock(flow_id)
+        async with flow_lock:
+            result = await self._reset_langflow_flow_locked(flow_type, flow_id)
+        if result.get("success"):
+            self._custom_updates_cache = None
+            try:
+                config = get_openrag_config()
+                if config.edited:
+                    from api.settings import reapply_all_settings
+
+                    await reapply_all_settings()
+            except Exception as e:
+                logger.error(f"Error reapplying settings after flow reset: {e}")
+        return result
+
+    async def _unlock_flow(self, flow_id: str):
+        """Unlock a flow before making changes."""
+        try:
+            response = await clients.langflow_request(
+                "PATCH", f"/api/v1/flows/{flow_id}", json={"locked": False}
+            )
+            if response.status_code not in (200, 404):
+                logger.warning(
+                    f"Failed to unlock flow {flow_id}: HTTP {response.status_code} - {response.text}"
+                )
+        except Exception as e:
+            logger.warning(f"Error unlocking flow {flow_id}: {e}")
+
+    async def _lock_flow(self, flow_id: str):
+        """Lock a flow after making changes."""
+        try:
+            response = await clients.langflow_request(
+                "PATCH", f"/api/v1/flows/{flow_id}", json={"locked": True}
+            )
+            if response.status_code not in (200, 404):
+                logger.warning(
+                    f"Failed to lock flow {flow_id}: HTTP {response.status_code} - {response.text}"
+                )
+        except Exception as e:
+            logger.warning(f"Error locking flow {flow_id}: {e}")
+
+    async def _reset_langflow_flow_locked(self, flow_type: str, flow_id: str):
+        if not LANGFLOW_URL:
+            raise ValueError("LANGFLOW_URL environment variable is required")
 
         # Dynamically find the flow file by ID
         flow_path = self._find_flow_file_by_id(flow_id)
@@ -481,6 +558,8 @@ class FlowsService:
         except FileNotFoundError as e:
             raise ValueError(f"Flow file not found: {flow_path}") from e
 
+        await self._unlock_flow(flow_id)
+
         # Make PATCH request to Langflow API to update the flow using shared client
         try:
             response = await clients.langflow_request(
@@ -488,73 +567,12 @@ class FlowsService:
             )
 
             if response.status_code == 200:
+                await self._lock_flow(flow_id)
                 logger.info(
                     f"Successfully reset {flow_type} flow",
                     flow_id=flow_id,
                     flow_file=os.path.basename(flow_path),
                 )
-
-                # Now update the flow with current configuration settings
-                try:
-                    config = get_openrag_config()
-
-                    # Check if configuration has been edited (onboarding completed)
-                    if config.edited:
-                        logger.info(
-                            f"Updating {flow_type} flow with current configuration settings"
-                        )
-
-                        # Update current LLM provider
-                        update_result = await self._update_provider_components(
-                            {"name": flow_type, "flow_id": flow_id},
-                            config.agent.llm_provider.lower(),
-                            llm_model=config.agent.llm_model,
-                            force_llm_update=True,
-                        )
-
-                        # Update all configured embedding providers
-                        embedding_providers = []
-                        if config.providers.openai.configured:
-                            embedding_providers.append("openai")
-                        if config.providers.watsonx.configured:
-                            embedding_providers.append("watsonx")
-                        if config.providers.ollama.configured:
-                            embedding_providers.append("ollama")
-
-                        current_emb_provider = config.knowledge.embedding_provider.lower()
-                        for provider in embedding_providers:
-                            model = (
-                                config.knowledge.embedding_model
-                                if provider == current_emb_provider
-                                else None
-                            )
-                            await self._update_provider_components(
-                                {"name": flow_type, "flow_id": flow_id},
-                                provider,
-                                embedding_model=model,
-                                force_embedding_update=True,
-                            )
-
-                        if update_result.get("success"):
-                            logger.info(
-                                f"Successfully updated {flow_type} flow with current configuration"
-                            )
-                        else:
-                            logger.warning(
-                                f"Failed to update {flow_type} flow with current configuration: {update_result.get('error', 'Unknown error')}"
-                            )
-                    else:
-                        logger.info(
-                            f"Configuration not yet edited (onboarding not completed), skipping model updates for {flow_type} flow"
-                        )
-
-                except Exception as e:
-                    logger.error(
-                        f"Error updating {flow_type} flow with current configuration",
-                        error=str(e),
-                    )
-                    # Don't fail the entire reset operation if configuration update fails
-
                 return {
                     "success": True,
                     "message": f"Successfully reset {flow_type} flow",
@@ -626,7 +644,7 @@ class FlowsService:
         return "OpenAI"
 
     async def _update_flow_field(
-        self, flow_id: str, field_name: str, field_value: Any, node_display_name: str = None
+        self, flow_id: str, field_name: str, field_value: Any, node_display_name: str | None = None
     ):
         """
         Generic helper function to update any field in any Langflow component.
@@ -683,6 +701,8 @@ class FlowsService:
             identifier = node_display_name
             raise Exception(f"{field_name} field not found in {identifier} component")
 
+        await self._unlock_flow(flow_id)
+
         # Update the flow via PATCH request
         patch_response = await clients.langflow_request(
             "PATCH", f"/api/v1/flows/{flow_id}", json=flow_data
@@ -692,6 +712,7 @@ class FlowsService:
             raise Exception(
                 f"Failed to update flow: HTTP {patch_response.status_code} - {patch_response.text}"
             )
+        await self._lock_flow(flow_id)
 
     async def update_chat_flow_model(self, model_name: str, provider: str):
         """Helper function to update the model in the chat flow"""
@@ -774,20 +795,34 @@ class FlowsService:
                 return True
         return False
 
-    def _normalize_flow_structure(self, flow_data):
+    def _normalize_flow_structure(self, flow_data: dict[str, Any]) -> dict[str, Any]:
         """
         Normalize flow structure for comparison by removing dynamic fields.
-        Keeps structural elements: nodes (types, display names, templates), edges (connections).
-        Removes: IDs, timestamps, positions, etc. but keeps template structure.
+        Keeps structural elements: nodes (types, display names, template definitions), edges (connections).
+        Removes: IDs, timestamps, positions, dynamic runtime field values, and dynamic options lists.
         """
-        normalized = {"data": {"nodes": [], "edges": []}}
+        normalized: dict[str, Any] = {"data": {"nodes": [], "edges": []}}
 
-        # Normalize nodes - keep structural info including templates
+        # Normalize nodes - keep structural info including template definitions
         nodes = flow_data.get("data", {}).get("nodes", [])
         for node in nodes:
             node_data = node.get("data", {})
             node_template = node_data.get("node", {})
 
+            template = node_template.get("template", {})
+            normalized_template: dict[str, Any] = {}
+            if isinstance(template, dict):
+                for field_name, field_def in template.items():
+                    if isinstance(field_def, dict):
+                        normalized_template[field_name] = {
+                            "type": field_def.get("type"),
+                            "display_name": field_def.get("display_name"),
+                            "required": field_def.get("required"),
+                            "input_types": field_def.get("input_types"),
+                        }
+                    else:
+                        normalized_template[field_name] = {"value": str(field_def)}
+
             normalized_node = {
                 "id": node.get("id"),  # Keep ID for edge matching
                 "type": node.get("type"),
@@ -796,7 +831,7 @@ class FlowsService:
                         "display_name": node_template.get("display_name"),
                         "name": node_template.get("name"),
                         "base_classes": node_template.get("base_classes", []),
-                        "template": node_template.get("template", {}),  # Include template structure
+                        "template": normalized_template,
                     }
                 },
             }
@@ -815,70 +850,51 @@ class FlowsService:
 
         return normalized
 
-    async def _compare_flow_with_file(self, flow_id: str):
+    async def _check_flow_update(
+        self, flow_type: str, flow_id: str, flow_data: dict[str, Any] | None = None
+    ) -> dict[str, Any] | None:
         """
-        Compare a Langflow flow with its JSON file.
-        Returns True if flows match (indicating a reset), False otherwise.
+        Check if a flow has a newer version on disk compared to Langflow.
+        Returns flow update info dict if an update is available, None otherwise.
         """
-        try:
-            # Get flow from Langflow API
-            response = await clients.langflow_request("GET", f"/api/v1/flows/{flow_id}")
-            if response.status_code != 200:
-                logger.warning(
-                    f"Failed to get flow {flow_id} from Langflow: HTTP {response.status_code}"
-                )
-                return False
-
-            langflow_flow = response.json()
-
-            # Find and load the corresponding JSON file
-            flow_path = self._find_flow_file_by_id(flow_id)
-            if not flow_path:
-                logger.warning(f"Flow file not found for flow ID: {flow_id}")
-                return False
-
-            with open(flow_path) as f:
-                file_flow = json.load(f)
-
-            # Normalize both flows for comparison
-            normalized_langflow = self._normalize_flow_structure(langflow_flow)
-            normalized_file = self._normalize_flow_structure(file_flow)
-
-            # Compare entire normalized structures exactly
-            # Sort nodes and edges for consistent comparison
-            normalized_langflow["data"]["nodes"] = sorted(
-                normalized_langflow["data"]["nodes"],
-                key=lambda x: (x.get("id", ""), x.get("type", "")),
-            )
-            normalized_file["data"]["nodes"] = sorted(
-                normalized_file["data"]["nodes"], key=lambda x: (x.get("id", ""), x.get("type", ""))
-            )
-
-            normalized_langflow["data"]["edges"] = sorted(
-                normalized_langflow["data"]["edges"],
-                key=lambda x: (
-                    x.get("source", ""),
-                    x.get("target", ""),
-                    x.get("sourceHandle", ""),
-                    x.get("targetHandle", ""),
-                ),
-            )
-            normalized_file["data"]["edges"] = sorted(
-                normalized_file["data"]["edges"],
-                key=lambda x: (
-                    x.get("source", ""),
-                    x.get("target", ""),
-                    x.get("sourceHandle", ""),
-                    x.get("targetHandle", ""),
-                ),
-            )
+        if not flow_id:
+            return None
+        flow_path = self._find_flow_file_by_id(flow_id)
+        if not flow_path or not os.path.exists(flow_path):
+            return None
+        local_mtime = os.path.getmtime(flow_path)
 
-            # Compare entire normalized structures
-            return normalized_langflow == normalized_file
+        if flow_data is None:
+            try:
+                response = await clients.langflow_request("GET", f"/api/v1/flows/{flow_id}")
+                if response.status_code != 200:
+                    return None
+                flow_data = response.json()
+            except Exception as e:
+                logger.error(f"Failed to fetch flow {flow_id} for update check: {e}")
+                return None
 
-        except Exception as e:
-            logger.error(f"Error comparing flow {flow_id} with file: {str(e)}")
-            return False
+        langflow_updated_at_str = flow_data.get("updated_at")
+        langflow_mtime: float = 0.0
+        if langflow_updated_at_str:
+            if langflow_updated_at_str.endswith("Z"):
+                langflow_updated_at_str = langflow_updated_at_str[:-1] + "+00:00"
+            try:
+                dt = datetime.fromisoformat(langflow_updated_at_str)
+                if dt.tzinfo is None:
+                    dt = dt.replace(tzinfo=UTC)
+                langflow_mtime = dt.timestamp()
+            except ValueError:
+                pass
+
+        if local_mtime > langflow_mtime + 1.0:
+            is_locked = flow_data.get("locked", False)
+            return {
+                "flow_type": flow_type,
+                "flow_id": flow_id,
+                "is_custom": not is_locked,
+            }
+        return None
 
     async def ensure_flows_exist(self) -> set[str]:
         """
@@ -889,9 +905,6 @@ class FlowsService:
         patches or overwrites an existing flow, preserving any edits the user
         has made in the Langflow UI.
 
-        This replaces the LANGFLOW_LOAD_FLOWS_PATH mechanism, which performed a
-        blind upsert on every container start and discarded user edits.
-
         Returns the set of flow type names that were actually created.
         """
         flow_configs = [
@@ -951,47 +964,31 @@ class FlowsService:
         tasks = [ensure_single_flow_exists(ft, fi) for ft, fi in flow_configs]
         results = await asyncio.gather(*tasks)
         created_flow_types = {r for r in results if r is not None}
-        return created_flow_types
 
-    async def check_flows_reset(self):
-        """
-        Check if any flows have been reset by comparing with JSON files.
-        Returns list of flow types that were reset.
-        """
-        reset_flows = []
-
-        flow_configs = [
-            ("nudges", NUDGES_FLOW_ID),
-            ("retrieval", LANGFLOW_CHAT_FLOW_ID),
-            ("ingest", LANGFLOW_INGEST_FLOW_ID),
-            ("url_ingest", LANGFLOW_URL_INGEST_FLOW_ID),
-        ]
+        if created_flow_types:
+            try:
+                config = get_openrag_config()
+                if config.edited:
+                    logger.info(
+                        f"Newly created flows detected ({', '.join(created_flow_types)}), reapplying settings."
+                    )
+                    from api.settings import reapply_all_settings
 
-        async def check_single_flow_reset(flow_type, flow_id):
-            if not flow_id:
-                return None
-            logger.info(f"Checking if {flow_type} flow (ID: {flow_id}) was reset")
-            is_reset = await self._compare_flow_with_file(flow_id)
-            if is_reset:
-                logger.info(f"Flow {flow_type} (ID: {flow_id}) appears to have been reset")
-                return flow_type
-            else:
-                logger.info(f"Flow {flow_type} (ID: {flow_id}) does not match reset state")
-                return None
+                    await reapply_all_settings()
+                    logger.info("Successfully reapplied settings for newly created flows")
+            except Exception as e:
+                logger.error(f"Failed to reapply settings for newly created flows: {e}")
 
-        tasks = [check_single_flow_reset(ft, fi) for ft, fi in flow_configs]
-        results = await asyncio.gather(*tasks)
-        reset_flows = [r for r in results if r is not None]
-        return reset_flows
+        return created_flow_types
 
     async def change_langflow_model_value(
         self,
         provider: str,
-        embedding_model: str = None,
-        llm_model: str = None,
+        embedding_model: str | None = None,
+        llm_model: str | None = None,
         force_embedding_update: bool = False,
         force_llm_update: bool = False,
-        flow_configs: list = None,
+        flow_configs: list | None = None,
     ):
         """
         Change dropdown values for provider-specific components across flows
@@ -1052,35 +1049,55 @@ class FlowsService:
 
     async def _update_provider_components(
         self,
-        config,
-        provider: str,
-        embedding_model: str = None,
-        llm_model: str = None,
+        config: dict,
+        provider_name: str,
+        embedding_model: str | None = None,
+        llm_model: str | None = None,
         force_embedding_update: bool = False,
         force_llm_update: bool = False,
     ):
         """Update provider components and their dropdown values in a flow"""
-        flow_name = config["name"]
         flow_id = config["flow_id"]
-        # Use a flow-specific lock to prevent race conditions during the GET-Modify-PATCH cycle
         flow_lock = await self._get_flow_lock(flow_id)
         async with flow_lock:
-            # Get flow data from Langflow API instead of file
-            response = await clients.langflow_request("GET", f"/api/v1/flows/{flow_id}")
+            return await self._update_provider_components_locked(
+                config,
+                provider_name,
+                embedding_model=embedding_model,
+                llm_model=llm_model,
+                force_embedding_update=force_embedding_update,
+                force_llm_update=force_llm_update,
+            )
 
-            if response.status_code != 200:
-                raise Exception(
-                    f"Failed to get flow from Langflow: HTTP {response.status_code} - {response.text}"
-                )
+    async def _update_provider_components_locked(
+        self,
+        config: dict,
+        provider_name: str,
+        embedding_model: str | None = None,
+        llm_model: str | None = None,
+        force_embedding_update: bool = False,
+        force_llm_update: bool = False,
+    ):
+        """Internal helper to update provider components when flow_lock is already held"""
+        flow_name = config["name"]
+        flow_id = config["flow_id"]
+        # Get flow data from Langflow API instead of file
+        response = await clients.langflow_request("GET", f"/api/v1/flows/{flow_id}")
 
-            flow_data = response.json()
-            updates_made = []
-            node_tasks = []
+        if response.status_code != 200:
+            raise Exception(
+                f"Failed to get flow from Langflow: HTTP {response.status_code} - {response.text}"
+            )
 
-            async def wrap_node_update(node, p, m, label):
-                if await self._update_component_fields(node, p, m):
-                    return label
-                return None
+        flow_data = response.json()
+        provider = provider_name
+        updates_made = []
+        node_tasks: list[Any] = []
+
+        async def wrap_node_update(node, p, m, label):
+            if await self._update_component_fields(node, p, m):
+                return label
+            return None
 
             # Update embedding component
             if not get_openrag_config().knowledge.disable_ingest_with_langflow and (
@@ -1205,39 +1222,41 @@ class FlowsService:
                         )
                     )
 
-            # Execute all node updates simultaneously
-            if node_tasks:
-                node_results = await asyncio.gather(*node_tasks)
-                updates_made.extend([r for r in node_results if r])
-
-            # If no updates were made, return skip message
-            if not updates_made:
-                return {
-                    "flow": flow_name,
-                    "success": True,
-                    "message": f"No compatible components found in {flow_name} flow (skipped)",
-                    "flow_id": flow_id,
-                }
-
-            logger.info(f"Updated {', '.join(updates_made)} in {flow_name} flow")
-
-            # PATCH the updated flow
-            response = await clients.langflow_request(
-                "PATCH", f"/api/v1/flows/{flow_id}", json=flow_data
-            )
-
-            if response.status_code != 200:
-                raise Exception(
-                    f"Failed to update flow: HTTP {response.status_code} - {response.text}"
-                )
+        # Execute all node updates simultaneously
+        if node_tasks:
+            node_results = await asyncio.gather(*node_tasks)
+            updates_made.extend([r for r in node_results if r])
 
+        # If no updates were made, return skip message
+        if not updates_made:
             return {
                 "flow": flow_name,
                 "success": True,
-                "message": f"Successfully updated {', '.join(updates_made)}",
+                "message": f"No compatible components found in {flow_name} flow (skipped)",
                 "flow_id": flow_id,
             }
 
+        logger.info(f"Updated {', '.join(updates_made)} in {flow_name} flow")
+
+        await self._unlock_flow(flow_id)
+
+        # PATCH the updated flow
+        response = await clients.langflow_request(
+            "PATCH", f"/api/v1/flows/{flow_id}", json=flow_data
+        )
+
+        if response.status_code != 200:
+            raise Exception(f"Failed to update flow: HTTP {response.status_code} - {response.text}")
+
+        await self._lock_flow(flow_id)
+
+        return {
+            "flow": flow_name,
+            "success": True,
+            "message": f"Successfully updated {', '.join(updates_made)}",
+            "flow_id": flow_id,
+        }
+
     async def _update_component_langflow(self, template, model: Any):
         # Call custom_component/update endpoint to get updated template
         # Only call if code field exists (custom components should have code)
@@ -1445,3 +1464,174 @@ class FlowsService:
         elif provider == "anthropic":
             return (None, "Anthropic")
         return (None, None)
+
+    async def get_flows_updates_available(self, user_id: str | None = None) -> list[dict[str, Any]]:
+        """
+        Check for available flow updates.
+        Uses cached update results from startup/previous checks if available.
+        Surfaces all available updates regardless of locked status.
+        """
+        target_user = user_id or "default"
+        if not hasattr(self, "_custom_updates_cache") or self._custom_updates_cache is None:
+            flow_configs = [
+                ("nudges", NUDGES_FLOW_ID),
+                ("retrieval", LANGFLOW_CHAT_FLOW_ID),
+                ("ingest", LANGFLOW_INGEST_FLOW_ID),
+                ("url_ingest", LANGFLOW_URL_INGEST_FLOW_ID),
+            ]
+            cache = []
+            for flow_type, flow_id in flow_configs:
+                update_info = await self._check_flow_update(flow_type, flow_id)
+                if update_info:
+                    cache.append(update_info)
+            self._custom_updates_cache = cache
+
+        updates = []
+        for item in self._custom_updates_cache:
+            is_dismissed = False
+            if hasattr(self, "_dismissed_updates") and isinstance(self._dismissed_updates, dict):
+                is_dismissed = item["flow_type"] in self._dismissed_updates.get(target_user, set())
+            updates.append(
+                {
+                    **item,
+                    "dismissed": is_dismissed,
+                }
+            )
+
+        return updates
+
+    async def bulk_update_flows(self, flow_types: list[str], backup_custom: bool = True):
+        """
+        Bulk updates multiple flows.
+        If backup_custom is True, flows are backed up in Langflow before resetting.
+        Local file backups are always saved via _backup_flow prior to resetting.
+        Returns the backup flow details if any.
+        """
+        results: list[dict[str, Any]] = []
+        flow_configs_dict = {
+            "nudges": NUDGES_FLOW_ID,
+            "retrieval": LANGFLOW_CHAT_FLOW_ID,
+            "ingest": LANGFLOW_INGEST_FLOW_ID,
+            "url_ingest": LANGFLOW_URL_INGEST_FLOW_ID,
+        }
+
+        for flow_type in flow_types:
+            flow_id = flow_configs_dict.get(flow_type)
+            if not flow_id:
+                results.append(
+                    {"flow_type": flow_type, "success": False, "error": "Invalid flow_type"}
+                )
+                continue
+
+            flow_lock = await self._get_flow_lock(flow_id)
+            async with flow_lock:
+                backup_path = None
+                backup_flow_id = None
+                flow_check_ok = False
+
+                try:
+                    response = await clients.langflow_request("GET", f"/api/v1/flows/{flow_id}")
+                    if response.status_code == 200:
+                        flow_check_ok = True
+                        flow_data = response.json()
+
+                        # Always attempt local file backup for safety
+                        backup_path = await self._backup_flow(flow_id, flow_type, flow_data)
+
+                        if backup_custom:
+                            logger.info(f"Backing up flow {flow_type} in Langflow before update.")
+                            # Create a backup flow directly in Langflow
+                            backup_payload = dict(flow_data)
+                            backup_payload.pop("id", None)
+                            flow_name = flow_data.get("name", flow_type.capitalize())
+                            timestamp = datetime.now().strftime("%Y-%m-%d %H:%M")
+                            backup_payload["name"] = f"Backup - {flow_name} ({timestamp})"
+                            backup_payload["description"] = (
+                                f"Backup of flow '{flow_name}' created before flow update on {timestamp}. "
+                                "Use this flow to reference or redo your modifications."
+                            )
+                            backup_payload["locked"] = False
+
+                            lf_create_res = await clients.langflow_request(
+                                "POST", "/api/v1/flows/", json=backup_payload
+                            )
+                            if lf_create_res.status_code in (200, 201):
+                                created_flow = lf_create_res.json()
+                                backup_flow_id = created_flow.get("id")
+                                logger.info(
+                                    f"Created backup flow in Langflow for {flow_type}: '{backup_payload['name']}' (ID: {backup_flow_id})"
+                                )
+                            else:
+                                logger.warning(
+                                    f"Failed to create backup flow in Langflow for {flow_type}: HTTP {lf_create_res.status_code}"
+                                )
+                except Exception as e:
+                    logger.error(f"Failed to check/backup flow {flow_id} before update: {e}")
+
+                if not flow_check_ok:
+                    logger.error(
+                        f"Pre-flight check failed for flow {flow_type}; aborting update to protect flow modifications."
+                    )
+                    results.append(
+                        {
+                            "flow_type": flow_type,
+                            "success": False,
+                            "error": "Pre-flight check failed; update aborted to avoid losing changes",
+                            "backup_path": None,
+                            "backup_flow_id": None,
+                        }
+                    )
+                    continue
+
+                # If backup_custom is enabled, abort update if BOTH backups failed
+                if backup_custom and backup_path is None and backup_flow_id is None:
+                    logger.error(
+                        f"Backup failed for flow {flow_type}; aborting update to protect flow modifications."
+                    )
+                    results.append(
+                        {
+                            "flow_type": flow_type,
+                            "success": False,
+                            "error": "Backup failed; update aborted to avoid losing changes",
+                            "backup_path": None,
+                            "backup_flow_id": None,
+                        }
+                    )
+                    continue
+
+                try:
+                    reset_res = await self._reset_langflow_flow_locked(flow_type, flow_id)
+                    if reset_res.get("success"):
+                        self.clear_dismissed_update(flow_type)
+                    results.append(
+                        {
+                            "flow_type": flow_type,
+                            "success": reset_res.get("success", False),
+                            "error": reset_res.get("error"),
+                            "backup_path": backup_path,
+                            "backup_flow_id": backup_flow_id,
+                        }
+                    )
+                except Exception as e:
+                    results.append(
+                        {
+                            "flow_type": flow_type,
+                            "success": False,
+                            "error": str(e),
+                            "backup_path": backup_path,
+                            "backup_flow_id": backup_flow_id,
+                        }
+                    )
+
+        if results and any(r.get("success") for r in results):
+            self._custom_updates_cache = None
+            try:
+                config = get_openrag_config()
+                if config.edited:
+                    from api.settings import reapply_all_settings
+
+                    await reapply_all_settings()
+            except Exception as e:
+                logger.error(f"Error reapplying settings after bulk update: {e}")
+
+        return results

services/startup_orchestrator.py

@@ -170,13 +170,11 @@ async def startup_tasks(services):
     # Update MCP server URLs (patch localhost and convert to streamable HTTP)
     await _update_mcp_server_urls(services["langflow_mcp_service"])
 
-    # Ensure all configured flows exist in Langflow (create-only, never overwrites).
-    # This replaces LANGFLOW_LOAD_FLOWS_PATH, which performed a blind upsert on
-    # every container start and discarded any user edits made in the Langflow UI.
-    newly_created: set[str] = set()
+    # Ensure all configured flows exist in Langflow (create-only, never overwrites existing).
+    # If a flow does not exist, it is created and active configuration settings are reapplied.
     try:
         flows_service = services["flows_service"]
-        newly_created = await flows_service.ensure_flows_exist()
+        await flows_service.ensure_flows_exist()
     except Exception as e:
         logger.error(
             "Failed to ensure Langflow flows exist at startup — "
@@ -184,38 +182,4 @@ async def startup_tasks(services):
             error=str(e),
         )
 
-    # Check if flows were reset and reapply settings if config is edited
-    try:
-        config = get_openrag_config()
-        if config.edited:
-            logger.info("Checking if Langflow flows were reset")
-            flows_service = services["flows_service"]
-            reset_flows = await flows_service.check_flows_reset()
-            # Exclude flows that were just seeded — they match the JSON by design,
-            # not because they were externally reset.
-            reset_flows = [f for f in reset_flows if f not in newly_created]
-
-            if reset_flows:
-                logger.info(
-                    f"Detected reset flows: {', '.join(reset_flows)}. Reapplying all settings."
-                )
-                await TelemetryClient.send_event(
-                    Category.FLOW_OPERATIONS, MessageId.ORB_FLOW_RESET_DETECTED
-                )
-                from api.settings import reapply_all_settings
 
-                await reapply_all_settings(session_manager=services["session_manager"])
-                logger.info("Successfully reapplied settings after detecting flow resets")
-                await TelemetryClient.send_event(
-                    Category.FLOW_OPERATIONS, MessageId.ORB_FLOW_SETTINGS_REAPPLIED
-                )
-            else:
-                logger.info("No flows detected as reset, skipping settings reapplication")
-        else:
-            logger.debug("Configuration not yet edited, skipping flow reset check")
-    except Exception as e:
-        logger.error(f"Failed to check flows reset or reapply settings: {str(e)}")
-        await TelemetryClient.send_event(
-            Category.FLOW_OPERATIONS, MessageId.ORB_FLOW_RESET_CHECK_FAIL
-        )
-        # Don't fail startup if this check fails