Answer workspace/workspaceFolders regardless of client capability

tombi sends this server-to-client request from its `initialized`
handling even though LspService declares workspace.workspaceFolders
false, and with no handler registered the client answered "Method not
found", which tombi treats as a fatal handshake error.

- LspService now always registers a workspace/workspaceFolders handler
  and answers it with the folders passed at initialize (fixed for the
  lifetime of a session, so there is nothing dynamic to report).
- Store those folders on the service so the handler can return them,
  clearing them on reset like the other per-session LSP state.
- Update the stale comment in tombi_lsp_service.py: the capability flag
  no longer decides whether the request arrives, only whether tombi
  is told support for dynamic updates exists.

Author: Aksem

extensions/fine_toml_tombi/fine_toml_tombi/tombi_lsp_service.py

@@ -38,9 +38,10 @@
         },
     },
     "workspace": {
-        # workspaceFolders must stay False: LspService has no workspace/workspaceFolders
-        # request handler. Declaring True would tell tombi we support the pull-based
-        # request, but we pass folders once in initialize — no dynamic updates needed.
+        # tombi sends workspace/workspaceFolders from its `initialized` handling
+        # regardless of this flag, so the flag no longer decides whether the
+        # request arrives; LspService answers it with the folders passed in
+        # initialize. Kept False because the folders never change dynamically.
         "workspaceFolders": False,
         "configuration": True,
     },

finecode_extension_api/src/finecode_extension_api/contrib/lsp_service.py

@@ -181,6 +181,9 @@ def __init__(
         # whether the server asked to be told about workspace file changes via
         # client/registerCapability; gate `workspace/didChangeWatchedFiles`.
         self._registered_watched_files = False
+        # folders sent in initialize; a server may ask for them again via
+        # `workspace/workspaceFolders`, so they are kept to answer that request
+        self._workspace_folders: list[dict[str, str]] = []
 
     @override
     async def init(self) -> None:
@@ -213,6 +216,7 @@ async def _async_dispose(self) -> None:
         self._server_capabilities = {}
         self._root_path = None
         self._registered_watched_files = False
+        self._workspace_folders = []
 
     async def ensure_started(
         self,
@@ -227,10 +231,11 @@ async def start(
         self,
         root_uri: str,
     ) -> None:
+        workspace_folders = [{"uri": root_uri, "name": root_uri}]
         session = self._lsp_client.session(
             cmd=self._cmd,
             root_uri=root_uri,
-            workspace_folders=[{"uri": root_uri, "name": root_uri}],
+            workspace_folders=workspace_folders,
             initialization_options=(
                 {"settings": self._settings} if self._settings else None
             ),
@@ -241,6 +246,7 @@ async def start(
         self._session = session
         self._root_path = resource_uri_to_path(root_uri)
         self._server_capabilities = session.server_capabilities
+        self._workspace_folders = workspace_folders
         self._session.on_notification(
             "textDocument/publishDiagnostics",
             self._handle_diagnostics,
@@ -267,6 +273,13 @@ async def start(
             "workspace/inlayHint/refresh",
             self._handle_inlay_hint_refresh,
         )
+        # Some servers (e.g. tombi) send workspace/workspaceFolders from their
+        # `initialized` handling regardless of the client capability, so this
+        # needs a handler even when `workspace.workspaceFolders` is false.
+        self._session.on_request(
+            "workspace/workspaceFolders",
+            self._handle_workspace_folders_request,
+        )
 
         # some LSP servers read settings from didChangeConfiguration (e.g. pyrefly)
         if self._settings:
@@ -1418,6 +1431,16 @@ async def _handle_inlay_hint_refresh(self, params: dict[str, Any] | None) -> Non
         """
         return
 
+    async def _handle_workspace_folders_request(
+        self, params: dict[str, Any] | None
+    ) -> list[dict[str, str]]:
+        """Handle the workspace/workspaceFolders pull request.
+
+        The folders are the fixed set this session was started with; there is
+        no dynamic change to report.
+        """
+        return self._workspace_folders
+
     async def _handle_configuration_request(
         self, params: dict[str, Any] | None
     ) -> list[dict[str, Any]]:

finecode_extension_api/tests/test_lsp_service.py

@@ -60,6 +60,9 @@ def __init__(self) -> None:
         # What the server advertised in its initialize result. Declaring
         # `diagnosticProvider` here is what puts the service on the pull path.
         self.capabilities: dict[str, Any] = {}
+        # Handlers registered with on_request, keyed by method, so a test can
+        # invoke the client side of a server-to-client request directly.
+        self.request_handlers: dict[str, Any] = {}
 
     async def __aenter__(self) -> "_FakeLspSession":
         return self
@@ -106,7 +109,7 @@ def on_notification(self, method: str, handler: Any) -> None:
         pass
 
     def on_request(self, method: str, handler: Any) -> None:
-        pass
+        self.request_handlers[method] = handler
 
     @property
     def server_capabilities(self) -> dict[str, Any]:
@@ -1210,6 +1213,22 @@ async def test_unregistered_service_drops_a_nonempty_watched_file_batch(
         ]
 
 
+async def test_workspace_folders_request_is_answered_with_initial_folders(
+    tmp_path: Path,
+) -> None:
+    """Some servers (tombi) pull the workspace folders regardless of the
+    workspace.workspaceFolders capability. The request has to be answered with
+    the folder passed at initialize, not Method not found."""
+    subject = tmp_path / "subject.py"
+
+    async with _running_service(subject, "x = 1\n") as (_, session, _):
+        handler = session.request_handlers["workspace/workspaceFolders"]
+        result = await handler(None)
+
+        root_uri = subject.parent.as_uri()
+        assert result == [{"uri": root_uri, "name": root_uri}]
+
+
 async def test_watched_file_create_and_delete_after_registration(
     tmp_path: Path,
 ) -> None: