fix: release SQLite lock after API key auth (#14381)

* fix: release SQLite lock after API key auth

* [autofix.ci] apply automated fixes

* fix: isolate API key bookkeeping transaction

* fix: isolate API key authentication transactions

---------

Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>

Author: erichare

.secrets.baseline

@@ -1068,7 +1068,7 @@
         "filename": "src/backend/base/langflow/services/database/models/api_key/crud.py",
         "hashed_secret": "920f8f5815b381ea692e9e7c2f7119f2b1aa620a",
         "is_verified": false,
-        "line_number": 139,
+        "line_number": 173,
         "is_secret": false
       }
     ],
@@ -7203,5 +7203,5 @@
       }
     ]
   },
-  "generated_at": "2026-07-30T21:43:28Z"
+  "generated_at": "2026-08-03T20:07:18Z"
 }

src/backend/base/langflow/__main__.py

@@ -918,17 +918,13 @@ async def _create_superuser(username: str, password: str, auth_token: str | None
         # Validate the auth token
         try:
             auth_user = None
-            async with session_scope() as session:
-                # Try JWT first
-                user = None
-                try:
-                    user = await get_current_user_from_access_token(auth_token, session)
-                except (InvalidTokenError, HTTPException):
-                    # Try API key
-                    api_key_result = await check_key(session, auth_token)
-                    if api_key_result and hasattr(api_key_result, "is_superuser"):
-                        user = api_key_result
-                auth_user = user
+            # Try JWT first, closing its session before falling back to API-key
+            # authentication, which owns a separate database transaction.
+            try:
+                async with session_scope() as session:
+                    auth_user = await get_current_user_from_access_token(auth_token, session)
+            except (InvalidTokenError, HTTPException):
+                auth_user = await check_key(auth_token)
 
             if not auth_user or not auth_user.is_superuser:
                 typer.echo(

src/backend/base/langflow/api/v1/a2a.py

@@ -124,41 +124,41 @@ async def _enforce_a2a_auth(flow: Flow, request: Request) -> User | None:
     - anything else (an auth type A2A doesn't understand) -> fail closed with 403: treating a
       *protected* folder as public would expose an owner-identity run anonymously.
 
-    Uses ``check_key`` directly, NOT ``api_key_security``: under AUTO_LOGIN the latter
+    Uses ``authenticate_api_key`` directly, NOT ``api_key_security``: under AUTO_LOGIN the latter
     returns the superuser for a *missing* key, which would silently bypass this gate.
     """
-    # Short writable session (check_key flushes usage counters), closed before
-    # dispatch so no lock is held across the up-to-300s run.
-    async with session_scope() as session:
+    # Resolve the folder policy first, then close that read session before API-key
+    # authentication opens its owned write transaction.
+    async with session_scope_readonly() as session:
         auth_type = await folder_auth_type(flow, session)
-        if auth_type == "none":
-            return None  # public agent
-        if auth_type not in ("apikey", "oauth"):
-            # Protected folder with a scheme A2A can't enforce: fail closed, never public.
-            raise HTTPException(
-                status_code=status.HTTP_403_FORBIDDEN,
-                detail=f"A2A access is disabled for this agent: unsupported folder auth type {auth_type!r}.",
-            )
-        api_key = request.headers.get(A2A_APIKEY_HEADER)
-        if not api_key:
-            raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="API key required")
-        api_key_result = await authenticate_api_key(session, api_key)
-        # Same message for invalid and wrong-owner: don't reveal a key is valid for another user.
-        if api_key_result is None or api_key_result.user.id != flow.user_id:
-            raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid API key")
-        user = api_key_result.user
-        set_current_auth_context(AuthCredentialContext.from_api_key_result(api_key_result))
-        try:
-            await ensure_flow_permission(
-                user,
-                FlowAction.EXECUTE,
-                flow_id=flow.id,
-                flow_user_id=flow.user_id,
-                folder_id=flow.folder_id,
-            )
-        except HTTPException as exc:
-            raise deny_to_404(exc, detail="Not Found") from exc
-        return user
+    if auth_type == "none":
+        return None  # public agent
+    if auth_type not in ("apikey", "oauth"):
+        # Protected folder with a scheme A2A can't enforce: fail closed, never public.
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail=f"A2A access is disabled for this agent: unsupported folder auth type {auth_type!r}.",
+        )
+    api_key = request.headers.get(A2A_APIKEY_HEADER)
+    if not api_key:
+        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="API key required")
+    api_key_result = await authenticate_api_key(api_key)
+    # Same message for invalid and wrong-owner: don't reveal a key is valid for another user.
+    if api_key_result is None or api_key_result.user.id != flow.user_id:
+        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid API key")
+    user = api_key_result.user
+    set_current_auth_context(AuthCredentialContext.from_api_key_result(api_key_result))
+    try:
+        await ensure_flow_permission(
+            user,
+            FlowAction.EXECUTE,
+            flow_id=flow.id,
+            flow_user_id=flow.user_id,
+            folder_id=flow.folder_id,
+        )
+    except HTTPException as exc:
+        raise deny_to_404(exc, detail="Not Found") from exc
+    return user
 
 
 class _FlowContextBuilder(DefaultServerCallContextBuilder):

src/backend/base/langflow/api/v1/mcp_projects.py

@@ -34,7 +34,6 @@
 from mcp.server.streamable_http_manager import StreamableHTTPSessionManager
 from sqlalchemy.orm import selectinload
 from sqlmodel import select
-from sqlmodel.ext.asyncio.session import AsyncSession
 
 from langflow.api.utils import (
     CurrentActiveMCPUser,
@@ -91,7 +90,6 @@
 
 
 async def verify_project_auth(
-    db: AsyncSession,
     project_id: UUID,
     query_param: str | None,
     header_param: str | None,
@@ -110,26 +108,26 @@ async def verify_project_auth(
 
     settings_service = get_settings_service()
 
-    project = (await db.exec(select(Folder).where(Folder.id == project_id))).first()
-
-    if not project:
-        raise HTTPException(status_code=404, detail="Project not found")
-
-    auth_settings: AuthSettings | None = None
-    # Check if this project requires API key only authentication
-    if project.auth_settings:
-        auth_settings = AuthSettings(**project.auth_settings)
+    # Resolve project authentication policy before API-key authentication opens
+    # its owned transaction. Keep only scalar values after this scope exits.
+    async with session_scope() as db:
+        project = (await db.exec(select(Folder).where(Folder.id == project_id))).first()
+        if not project:
+            raise HTTPException(status_code=404, detail="Project not found")
+        project_user_id = project.user_id
+        auth_settings = AuthSettings(**project.auth_settings) if project.auth_settings else None
 
     project_auth_type = auth_settings.auth_type if auth_settings else None
     if project_auth_type == "oauth" and composer_backend_token:
         mcp_composer_service: MCPComposerService = cast(
             MCPComposerService, get_service(ServiceType.MCP_COMPOSER_SERVICE)
         )
         if mcp_composer_service.validate_backend_auth_token(str(project_id), composer_backend_token):
-            if project.user_id:
-                project_user = await db.get(User, project.user_id)
-                if project_user:
-                    return project_user
+            if project_user_id:
+                async with session_scope() as db:
+                    project_user = await db.get(User, project_user_id)
+                    if project_user:
+                        return project_user
             raise HTTPException(status_code=404, detail="Project owner not found")
 
     # OAuth projects must present a valid API key at the Langflow transport endpoint: network-level
@@ -159,33 +157,30 @@ async def verify_project_auth(
             )
 
         # Validate the API key
-        api_key_result = await authenticate_api_key(db, api_key)
+        api_key_result = await authenticate_api_key(api_key)
         if not api_key_result:
             raise HTTPException(status_code=401, detail="Invalid API key")
         set_current_auth_context(AuthCredentialContext.from_api_key_result(api_key_result))
         user = api_key_result.user
 
         # Verify user has access to the project
-        project_access = (
-            await db.exec(select(Folder).where(Folder.id == project_id, Folder.user_id == user.id))
-        ).first()
-
-        if not project_access:
+        if project_user_id != user.id:
             raise HTTPException(status_code=404, detail="Project not found")
 
         return user
 
-    return await _superuser_fallback(db, settings_service)
+    return await _superuser_fallback(settings_service)
 
 
-async def _superuser_fallback(db: AsyncSession, settings_service) -> User:
+async def _superuser_fallback(settings_service) -> User:
     """Resolve the configured superuser for unauthenticated MCP paths that allow fallback."""
     if not settings_service.auth_settings.SUPERUSER:
         raise HTTPException(
             status_code=status.HTTP_400_BAD_REQUEST,
             detail="Missing superuser username in auth settings",
         )
-    result = await get_user_by_username(db, settings_service.auth_settings.SUPERUSER)
+    async with session_scope() as db:
+        result = await get_user_by_username(db, settings_service.auth_settings.SUPERUSER)
     if result:
         logger.warning(AUTO_LOGIN_WARNING)
         set_current_auth_context(AuthCredentialContext(method=AUTH_METHOD_AUTO_LOGIN))
@@ -206,51 +201,47 @@ async def verify_project_auth_conditional(
     - MCP Composer enabled + API key auth: Only allow API keys
     - All other cases: Use standard MCP auth (JWT + API keys)
     """
+    # Extract token
+    token: str | None = None
+    auth_header = request.headers.get("authorization")
+    if auth_header and auth_header.startswith("Bearer "):
+        token = auth_header[7:]
+
+    # Extract API keys
+    api_key_query_value = request.query_params.get("x-api-key")
+    api_key_header_value = request.headers.get("x-api-key")
+    composer_backend_token = request.headers.get(COMPOSER_BACKEND_AUTH_HEADER)
+
+    # The composer path performs its own short project-policy read before auth.
+    if get_settings_service().settings.mcp_composer_enabled:
+        return await verify_project_auth(
+            project_id,
+            api_key_query_value,
+            api_key_header_value,
+            composer_backend_token,
+        )
+
+    # Preserve the existing not-found-before-auth behavior, but close this read
+    # scope before API-key authentication opens its owned transaction.
     async with session_scope() as session:
-        # Get project to check auth settings
         project = (await session.exec(select(Folder).where(Folder.id == project_id))).first()
-
         if not project:
             raise HTTPException(status_code=404, detail="Project not found")
+        project_user_id = project.user_id
 
-        # Extract token
-        token: str | None = None
-        auth_header = request.headers.get("authorization")
-        if auth_header and auth_header.startswith("Bearer "):
-            token = auth_header[7:]
-
-        # Extract API keys
-        api_key_query_value = request.query_params.get("x-api-key")
-        api_key_header_value = request.headers.get("x-api-key")
-        composer_backend_token = request.headers.get(COMPOSER_BACKEND_AUTH_HEADER)
-
-        # Check if this project requires API key only authentication
-        if get_settings_service().settings.mcp_composer_enabled:
-            return await verify_project_auth(
-                session,
-                project_id,
-                api_key_query_value,
-                api_key_header_value,
-                composer_backend_token,
-            )
-
-        # For all other cases, use standard MCP authentication (allows JWT + API keys)
-        # Call the MCP auth function directly
-        from langflow.services.auth.utils import get_current_user_mcp
+    # For all other cases, use standard MCP authentication (allows JWT + API keys).
+    # This session has not executed a query before API-key authentication.
+    from langflow.services.auth.utils import get_current_user_mcp
 
+    async with session_scope() as session:
         user = await get_current_user_mcp(
             token=token or "", query_param=api_key_query_value, header_param=api_key_header_value, db=session
         )
 
-        # Verify project access
-        project_access = (
-            await session.exec(select(Folder).where(Folder.id == project_id, Folder.user_id == user.id))
-        ).first()
-
-        if not project_access:
-            raise HTTPException(status_code=404, detail="Project not found")
+    if project_user_id != user.id:
+        raise HTTPException(status_code=404, detail="Project not found")
 
-        return user
+    return user
 
 
 # Create project-specific context variable