[autofix.ci] apply automated fixes

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

@@ -59,6 +59,7 @@ async def handle_global_call_tool(name: str, arguments: dict) -> list[types.Text
 # TODO: create environment variable for stateless flag
 streamable_http_manager = StreamableHTTPSessionManager(server, stateless=True)
 
+
 def find_validation_error(exc):
     """Searches for a pydantic.ValidationError in the exception chain."""
     while exc:
@@ -157,6 +158,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

@@ -77,7 +77,6 @@
 )
 
 
-
 async def verify_project_auth(
     db: AsyncSession,
     project_id: UUID,
@@ -212,7 +211,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,
@@ -319,7 +317,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()
 
 
@@ -344,9 +342,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)
@@ -432,8 +428,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(
@@ -444,8 +443,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 streamable_http_manager
+
             await logger.adebug("Starting MCP Server Streamable HTTP session manager")
             async with AsyncExitStack() as stack:
                 await stack.enter_async_context(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

@@ -601,13 +601,14 @@
     config_path = tmp_path / filename
     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
 
     monkeypatch.setattr("langflow.api.v1.mcp_projects.get_config_path", fake_get_config_path)
     monkeypatch.setattr("langflow.api.v1.mcp_projects.platform.system", lambda: "Linux")
     monkeypatch.setattr("langflow.api.v1.mcp_projects.should_use_mcp_composer", lambda project: False)
 
     async def fake_streamable(project_id):
         return f"https://langflow.local/api/v1/mcp/project/{project_id}/streamable"

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: