fix: address review feedback on LFX standalone fallback

- Expand comment on `except ModuleNotFoundError` narrowing to explicitly
  document the ImportError-vs-ModuleNotFoundError distinction.
- Bump fallback log from adebug to ainfo (mode switch is material).
- Simplify `getattr(e, "name", None) or ""` to `e.name or ""`.
- Add TODO(legacy-cleanup) marker flagging 800-line file debt.
- Rename fallback tests to `should_[expected]_when_[condition]` convention.
- Add regression tests: plain ImportError surfaces; lfx.services.deps
  missing surfaces (locks in prefix-check precedence).
- Document why `patch("builtins.__import__")` is necessary in tests.

Author: erichare

src/backend/tests/unit/components/models_and_agents/test_mcp_component.py

@@ -733,8 +733,17 @@ async def test_rest_api_new_server_scenario(self, component):
 
             # Connect should be called with API-provided config as fallback
 
+    # Tests below patch `builtins.__import__` to simulate import failures. This is a
+    # heavyweight approach — the patch intercepts *every* import executed while active,
+    # including unrelated library code pulled in by awaits, mocks, or assertions — but
+    # targeted alternatives (sys.modules / importlib) do not reliably reproduce the
+    # `ModuleNotFoundError` raised from an `import langflow.*` statement inside the
+    # code under test. The `real_import` fallback forwards all non-matching names to
+    # the real import machinery; the `name`-prefix guard in each fake_import is kept
+    # as tight as possible so surrounding test plumbing is not affected.
+
     @pytest.mark.asyncio
-    async def test_lfx_standalone_falls_back_to_value_config(self, component):
+    async def test_update_tool_list_falls_back_to_value_config_when_langflow_absent(self, component):
         """Test LFX standalone mode falls back to value config when Langflow is unavailable.
 
         Regression test: when lfx is run without the full Langflow package installed
@@ -780,7 +789,7 @@ def fake_import(name, import_globals=None, import_locals=None, fromlist=(), leve
             assert server_info["config"]["command"] == "uvx mcp-server-from-value"
 
     @pytest.mark.asyncio
-    async def test_transitive_import_error_surfaces(self, component):
+    async def test_update_tool_list_surfaces_transitive_import_error_instead_of_falling_back(self, component):
         """A transitive ModuleNotFoundError inside Langflow must NOT be silently swallowed.
 
         If a Langflow dependency (e.g. sqlmodel) fails to import while loading
@@ -825,6 +834,93 @@ def fake_import(name, import_globals=None, import_locals=None, fromlist=(), leve
 
             mock_update_tools.assert_not_called()
 
+    @pytest.mark.asyncio
+    async def test_update_tool_list_surfaces_plain_import_error_instead_of_falling_back(self, component):
+        """A plain ImportError (attribute missing, not module missing) must surface.
+
+        Regression test for the intentional `except ModuleNotFoundError` narrowing: if
+        an installed Langflow no longer exposes `get_server` or `get_user_by_id` (real
+        API break), the resulting ImportError — which is NOT a ModuleNotFoundError —
+        must NOT be swallowed as standalone mode. It must propagate to the outer
+        handler and surface as a `ValueError("Error updating tool list: ...")`.
+        """
+        import builtins
+
+        component.mcp_server = {
+            "name": "broken_server",
+            "config": {"command": "uvx mcp-server-from-value"},
+        }
+        component._user_id = "test_user_123"
+
+        real_import = builtins.__import__
+
+        def fake_import(name, import_globals=None, import_locals=None, fromlist=(), level=0):
+            # The module imports fine, but a specific attribute is missing — this
+            # raises plain ImportError (not ModuleNotFoundError) at the `from ... import`
+            # line. Emulate that by raising ImportError when this module is requested
+            # with a fromlist, just as `from langflow.api.v2.mcp import get_server` would.
+            if name == "langflow.api.v2.mcp" and fromlist and "get_server" in fromlist:
+                msg = "cannot import name 'get_server' from 'langflow.api.v2.mcp'"
+                raise ImportError(msg, name="langflow.api.v2.mcp")
+            return real_import(name, import_globals, import_locals, fromlist, level)
+
+        with (
+            patch("builtins.__import__", side_effect=fake_import),
+            patch("lfx.components.models_and_agents.mcp_component.update_tools") as mock_update_tools,
+        ):
+            mock_update_tools.return_value = (None, [], {})
+
+            with pytest.raises(ValueError, match="Error updating tool list") as exc_info:
+                await component.update_tool_list()
+
+            # The original ImportError should be preserved as __cause__ — it must not
+            # have been silently converted into a fallback path.
+            assert isinstance(exc_info.value.__cause__, ImportError)
+            assert not isinstance(exc_info.value.__cause__, ModuleNotFoundError)
+
+            mock_update_tools.assert_not_called()
+
+    @pytest.mark.asyncio
+    async def test_update_tool_list_surfaces_lfx_services_deps_missing(self, component):
+        """A ModuleNotFoundError for an lfx module (not langflow.*) must surface.
+
+        Edge-case regression test: if `lfx.services.deps` itself is missing (a
+        packaging error inside lfx), the prefix check `missing_module == "langflow"
+        or missing_module.startswith("langflow.")` correctly returns False and the
+        error is re-raised. Locks in the intended precedence rule so a future rewrite
+        of the prefix check cannot silently convert this into a standalone fallback.
+        """
+        import builtins
+
+        component.mcp_server = {
+            "name": "broken_server",
+            "config": {"command": "uvx mcp-server-from-value"},
+        }
+        component._user_id = "test_user_123"
+
+        real_import = builtins.__import__
+
+        deps_missing_msg = "No module named 'lfx.services.deps'"
+
+        def fake_import(name, import_globals=None, import_locals=None, fromlist=(), level=0):
+            if name == "lfx.services.deps" or name.startswith("lfx.services.deps."):
+                raise ModuleNotFoundError(deps_missing_msg, name="lfx.services.deps")
+            return real_import(name, import_globals, import_locals, fromlist, level)
+
+        with (
+            patch("builtins.__import__", side_effect=fake_import),
+            patch("lfx.components.models_and_agents.mcp_component.update_tools") as mock_update_tools,
+        ):
+            mock_update_tools.return_value = (None, [], {})
+
+            with pytest.raises(ValueError, match="Error updating tool list") as exc_info:
+                await component.update_tool_list()
+
+            assert isinstance(exc_info.value.__cause__, ModuleNotFoundError)
+            assert exc_info.value.__cause__.name == "lfx.services.deps"
+
+            mock_update_tools.assert_not_called()
+
 
 # ============================================================================
 # Tests for resolve_mcp_config pure function

src/lfx/src/lfx/components/models_and_agents/mcp_component.py

@@ -50,6 +50,9 @@ def resolve_mcp_config(
     return server_config_from_value
 
 
+# TODO(legacy-cleanup): This file is ~800 lines, over the 500-line guideline. Split
+# helper functions (resolve_mcp_config, connection resolution) from the MCPToolsComponent
+# orchestration logic in a follow-up PR.
 class MCPToolsComponent(ComponentWithCache):
     schema_inputs: list = []
     tools: list[StructuredTool] = []
@@ -240,17 +243,23 @@ async def update_tool_list(self, mcp_server_value=None):
 
                 from lfx.services.deps import get_settings_service
             except ModuleNotFoundError as e:
-                # Only treat this as LFX standalone mode when one of the target Langflow
-                # modules is itself missing. Transitive ModuleNotFoundError (e.g. a
-                # dependency like sqlmodel failing to import inside langflow.*) indicates
-                # a real bug in the full Langflow stack and must surface — otherwise we
-                # would silently use a stale flow-embedded config when DB config should
-                # have taken precedence.
-                missing_module = getattr(e, "name", None) or ""
+                # Deliberately `except ModuleNotFoundError` (not `except ImportError`): a
+                # plain ImportError here means `get_server` / `get_user_by_id` was removed
+                # from an installed Langflow — a real API break that should NOT be
+                # swallowed as "standalone mode". ModuleNotFoundError alone covers the
+                # "Langflow absent" case.
+                #
+                # Even within ModuleNotFoundError, only treat this as LFX standalone mode
+                # when one of the target Langflow modules is itself missing. Transitive
+                # ModuleNotFoundError (e.g. a dependency like sqlmodel failing to import
+                # inside langflow.*) indicates a real bug in the full Langflow stack and
+                # must surface — otherwise we would silently use a stale flow-embedded
+                # config when DB config should have taken precedence.
+                missing_module = e.name or ""
                 is_langflow_standalone = missing_module == "langflow" or missing_module.startswith("langflow.")
                 if not is_langflow_standalone:
                     raise
-                await logger.adebug(
+                await logger.ainfo(
                     "Langflow package not available; using MCP server config from flow value (LFX standalone mode)."
                 )
             else: