fix: stop overstating minimal LSP client support

The client was advertising publish-diagnostics version support and workspace
diagnostic refresh support without implementing either behavior, and
workspace/configuration always returned a single initialization blob instead
of one result per requested item.

Downgrade the unsupported capability claims and return configuration entries
in the shape servers expect so they don't assume features we don't actually
have.

Author: Hona

packages/opencode/src/lsp/client.ts

@@ -114,6 +114,15 @@ function dedupeDiagnostics(items: Diagnostic[]) {
   })
 }
 
+function configurationValue(settings: unknown, section?: string) {
+  if (!section) return settings ?? null
+  const result = section.split(".").reduce<unknown>((acc, key) => {
+    if (!acc || typeof acc !== "object" || !(key in acc)) return undefined
+    return (acc as Record<string, unknown>)[key]
+  }, settings)
+  return result ?? null
+}
+
 export async function create(input: { serverID: string; server: LSPServer.Handle; root: string; directory: string }) {
   const l = log.clone().tag("serverID", input.serverID)
   l.info("starting client")
@@ -171,8 +180,9 @@ export async function create(input: { serverID: string; server: LSPServer.Handle
     l.info("window/workDoneProgress/create", params)
     return null
   })
-  connection.onRequest("workspace/configuration", async () => {
-    return [input.server.initialization ?? {}]
+  connection.onRequest("workspace/configuration", async (params) => {
+    const items = (params as { items?: { section?: string }[] }).items ?? []
+    return items.map((item) => configurationValue(input.server.initialization, item.section))
   })
   connection.onRequest("client/registerCapability", async (params) => {
     const registrations = (params as { registrations?: CapabilityRegistration[] }).registrations ?? []
@@ -227,7 +237,7 @@ export async function create(input: { serverID: string; server: LSPServer.Handle
             dynamicRegistration: true,
           },
           diagnostics: {
-            refreshSupport: true,
+            refreshSupport: false,
           },
         },
         textDocument: {
@@ -240,7 +250,7 @@ export async function create(input: { serverID: string; server: LSPServer.Handle
             relatedDocumentSupport: true,
           },
           publishDiagnostics: {
-            versionSupport: true,
+            versionSupport: false,
           },
         },
       },

packages/opencode/test/fixture/lsp/fake-lsp-server.js

@@ -3,8 +3,10 @@
 let nextId = 1
 let readBuffer = Buffer.alloc(0)
 let lastChange = null
+let initializeParams = null
 let diagnosticRequestCount = 0
 let registeredCapability = false
+const pendingClientRequests = new Map()
 let pullConfig = {
   delayMs: 0,
   registerOn: undefined,
@@ -101,7 +103,16 @@ function handle(raw) {
     return
   }
 
+  if (typeof data.method === "undefined" && typeof data.id !== "undefined") {
+    const pending = pendingClientRequests.get(data.id)
+    if (!pending) return
+    pendingClientRequests.delete(data.id)
+    sendResponse(pending, data.result ?? null)
+    return
+  }
+
   if (data.method === "initialize") {
+    initializeParams = data.params
     sendResponse(data.id, {
       capabilities: {
         textDocumentSync: {
@@ -112,6 +123,17 @@ function handle(raw) {
     return
   }
 
+  if (data.method === "test/get-initialize-params") {
+    sendResponse(data.id, initializeParams)
+    return
+  }
+
+  if (data.method === "test/request-configuration") {
+    const id = sendRequest("workspace/configuration", data.params)
+    pendingClientRequests.set(id, data.id)
+    return
+  }
+
   if (data.method === "initialized" || data.method === "workspace/didChangeConfiguration") {
     return
   }

packages/opencode/test/lsp/client.test.ts

@@ -91,6 +91,59 @@ describe("LSPClient interop", () => {
     await client.shutdown()
   })
 
+  test("initialize does not overclaim unsupported diagnostics capabilities", async () => {
+    const handle = spawnFakeServer() as any
+
+    const client = await Instance.provide({
+      directory: process.cwd(),
+      fn: () =>
+        LSPClient.create({
+          serverID: "fake",
+          server: handle as unknown as LSPServer.Handle,
+          root: process.cwd(),
+          directory: process.cwd(),
+        }),
+    })
+
+    const params = await client.connection.sendRequest<any>("test/get-initialize-params", {})
+    expect(params.capabilities.workspace.diagnostics.refreshSupport).toBe(false)
+    expect(params.capabilities.textDocument.publishDiagnostics.versionSupport).toBe(false)
+
+    await client.shutdown()
+  })
+
+  test("workspace/configuration returns one result per requested item", async () => {
+    const handle = spawnFakeServer() as any
+    const initialization = {
+      alpha: {
+        beta: 1,
+      },
+      gamma: true,
+    }
+
+    const client = await Instance.provide({
+      directory: process.cwd(),
+      fn: () =>
+        LSPClient.create({
+          serverID: "fake",
+          server: {
+            ...(handle as unknown as LSPServer.Handle),
+            initialization,
+          },
+          root: process.cwd(),
+          directory: process.cwd(),
+        }),
+    })
+
+    const response = await client.connection.sendRequest<any[]>("test/request-configuration", {
+      items: [{ section: "alpha" }, { section: "alpha.beta" }, { section: "missing" }, {}],
+    })
+
+    expect(response).toEqual([{ beta: 1 }, 1, null, initialization])
+
+    await client.shutdown()
+  })
+
   test("sends ranged didChange for incremental sync servers", async () => {
     const handle = spawnFakeServer() as any
     await using tmp = await tmpdir()