[autofix.ci] apply automated fixes (attempt 2/3)

Author: autofix-ci[bot]

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

@@ -56,36 +56,42 @@ async def handle_global_call_tool(name: str, arguments: dict) -> list[types.Text
 
 
 sse = SseServerTransport("/api/v1/mcp/")
+
+
 ########################################################
 # SseServerTransport.connect_sse handles the full ASGI response internally
 # but FastAPI still expects the endpoint to return a Response,
 # this results in ungraceful termination of the SSE connection
 # We use this class to return a Response that FastAPI can handle gracefully
 ########################################################
 class SSECompletedNoOp(Response):
-    async def __call__(self, scope, receive, send) -> None: # noqa: ARG002
+    async def __call__(self, scope, receive, send) -> None:  # noqa: ARG002
         # connect_sse already produced the ASGI response; nothing left to send.
         return
 
+
 # Manage state of the Streamable HTTP session manager
 streamable_http_session_manager: StreamableHTTPSessionManager | None = None
 
+
 def init_streamable_http_manager(*, stateless: bool = True) -> StreamableHTTPSessionManager:
     """Create and register a Streamable HTTP session manager for the global MCP server."""
-    global streamable_http_session_manager # noqa: PLW0603
+    global streamable_http_session_manager  # noqa: PLW0603
     streamable_http_session_manager = StreamableHTTPSessionManager(server, stateless=stateless)
     return streamable_http_session_manager
 
+
 def get_streamable_http_manager() -> StreamableHTTPSessionManager:
     """Fetch the active Streamable HTTP session manager or raise if it is unavailable."""
-    global streamable_http_session_manager # noqa: PLW0602
+    global streamable_http_session_manager  # noqa: PLW0602
     if streamable_http_session_manager is None:
         raise HTTPException(status_code=503, detail="MCP Streamable HTTP transport is not initialized")
     return streamable_http_session_manager
 
+
 def clear_streamable_http_manager() -> None:
     """Clear the currently active Streamable HTTP session manager reference."""
-    global streamable_http_session_manager # noqa: PLW0603
+    global streamable_http_session_manager  # noqa: PLW0603
     streamable_http_session_manager = None
 
 
@@ -187,6 +193,8 @@ async def _dispatch_streamable_http(
 
 
 streamable_http_methods = ["GET", "POST", "DELETE"]
+
+
 @router.api_route("/streamable", methods=streamable_http_methods)
 @router.api_route("/streamable/", methods=streamable_http_methods)
 async def handle_streamable_http(request: Request, current_user: CurrentActiveMCPUser):

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

@@ -78,7 +78,6 @@
 )
 
 
-
 async def verify_project_auth(
     db: AsyncSession,
     project_id: UUID,
@@ -213,7 +212,6 @@ def get_project_sse(project_id: UUID | None) -> SseServerTransport:
     return project_sse_transports[project_id_str]
 
 
-
 async def _build_project_tools_response(
     project_id: UUID,
     current_user: CurrentActiveMCPUser,
@@ -320,7 +318,7 @@ async def im_alive(project_id: str):  # noqa: ARG001
 
 
 @router.head("/{project_id}/streamable", include_in_schema=False)
-async def streamable_health(project_id: UUID): # noqa: ARG001
+async def streamable_health(project_id: UUID):  # noqa: ARG001
     return Response()
 
 
@@ -345,9 +343,7 @@ async def _dispatch_project_streamable_http(
     except HTTPException:
         raise
     except Exception as exc:
-        await logger.aexception(
-            f"Error handling Streamable HTTP request for project {project_id}: {exc!s}"
-        )
+        await logger.aexception(f"Error handling Streamable HTTP request for project {project_id}: {exc!s}")
         raise HTTPException(status_code=500, detail="Internal server error in project MCP transport") from exc
     finally:
         current_request_variables_ctx.reset(request_vars_token)
@@ -433,8 +429,11 @@ async def _handle_project_sse_messages(
         current_project_ctx.reset(project_token)
         current_request_variables_ctx.reset(req_vars_token)
 
+
 # legacy SSE transport
 project_messages_methods = ["POST", "DELETE"]
+
+
 @router.api_route("/{project_id}", methods=project_messages_methods)
 @router.api_route("/{project_id}/", methods=project_messages_methods)
 async def handle_project_messages(
@@ -445,8 +444,11 @@ async def handle_project_messages(
     """Handle POST/DELETE messages for a project-specific MCP server."""
     return await _handle_project_sse_messages(project_id, request, current_user)
 
+
 # Streamable HTTP transport
 streamable_http_methods = ["GET", "POST", "DELETE"]
+
+
 @router.api_route("/{project_id}/streamable", methods=streamable_http_methods)
 @router.api_route("/{project_id}/streamable/", methods=streamable_http_methods)
 async def handle_project_streamable_http(

src/backend/base/langflow/main.py

@@ -308,8 +308,9 @@ async def delayed_init_mcp_servers():
             mcp_init_task = asyncio.create_task(delayed_init_mcp_servers())
 
             # Start streamable-http transport session manager for MCP server
-            from contextlib import AsyncExitStack # noqa: I001
+            from contextlib import AsyncExitStack  # noqa: I001
             from langflow.api.v1.mcp import init_streamable_http_manager
+
             await logger.adebug("Starting MCP Server Streamable HTTP session manager")
             async with AsyncExitStack() as stack:
                 await stack.enter_async_context(init_streamable_http_manager().run())

src/backend/tests/integration/test_projects_integration.py

@@ -12,10 +12,7 @@
 
 
 @pytest.mark.asyncio
-async def test_project_authentication_settings(
-    client: AsyncClient,
-    logged_in_headers
-):
+async def test_project_authentication_settings(client: AsyncClient, logged_in_headers):
     """Integration test: Project authentication settings configuration."""
     # Scenario 1: AUTO_LOGIN disabled -> API key auth
     with patch("langflow.api.v1.projects.get_settings_service") as mock_get_settings:

src/backend/tests/unit/api/v1/test_mcp.py

@@ -192,6 +192,7 @@ async def test_find_validation_error_with_pydantic_error():
     # Create a pydantic ValidationError by catching it
     validation_error = None
     try:
+
         class TestModel(pydantic.BaseModel):
             required_field: str
 
@@ -226,6 +227,7 @@ async def test_find_validation_error_with_context():
     # Create a pydantic ValidationError by catching it
     validation_error = None
     try:
+
         class TestModel(pydantic.BaseModel):
             required_field: str
 
@@ -263,8 +265,10 @@ async def test_mcp_sse_validation_error_logged():
     # Verify the function exists and works
     validation_error = None
     try:
+
         class TestModel(pydantic.BaseModel):
             required_field: str
+
         TestModel()
     except pydantic.ValidationError as e:
         validation_error = e

src/backend/tests/unit/api/v1/test_mcp_projects.py

@@ -602,6 +602,7 @@ def _prepare_install_test_env(monkeypatch, tmp_path, filename="cursor.json"):
     config_path.parent.mkdir(parents=True, exist_ok=True)
 
     monkeypatch.setattr("langflow.api.v1.mcp_projects.get_client_ip", lambda request: "127.0.0.1")
+
     async def fake_get_config_path(client_name):
         return config_path
 

src/lfx/src/lfx/services/mcp_composer/service.py

@@ -73,7 +73,9 @@ class MCPComposerService(Service):
 
     def __init__(self):
         super().__init__()
-        self.project_composers: dict[str, dict] = {}  # project_id -> {process, host, port, streamable_http_url, auth_config}
+        self.project_composers: dict[
+            str, dict
+        ] = {}  # project_id -> {process, host, port, streamable_http_url, auth_config}
         self._start_locks: dict[
             str, asyncio.Lock
         ] = {}  # Lock to prevent concurrent start operations for the same project
@@ -1045,9 +1047,7 @@ async def _do_start_project_composer(
 
         project_host = auth_config.get("oauth_host") if auth_config else "unknown"
         project_port = auth_config.get("oauth_port") if auth_config else "unknown"
-        await logger.adebug(
-            f"Starting MCP Composer for project {project_id} on {project_host}:{project_port}"
-        )
+        await logger.adebug(f"Starting MCP Composer for project {project_id} on {project_host}:{project_port}")
 
         # Use a per-project lock to prevent race conditions
         if project_id not in self._start_locks: