feat: Add configurable lsp timeout

Author: tjg184

packages/opencode/src/config/config.ts

@@ -876,21 +876,39 @@ export namespace Config {
       lsp: z
         .union([
           z.literal(false),
-          z.record(
-            z.string(),
-            z.union([
-              z.object({
-                disabled: z.literal(true),
-              }),
-              z.object({
-                command: z.array(z.string()),
-                extensions: z.array(z.string()).optional(),
-                disabled: z.boolean().optional(),
-                env: z.record(z.string(), z.string()).optional(),
-                initialization: z.record(z.string(), z.any()).optional(),
-              }),
-            ]),
-          ),
+          z
+            .object({
+              timeout: z
+                .number()
+                .int()
+                .positive()
+                .optional()
+                .describe(
+                  "Global timeout in milliseconds for LSP server initialization. Default is 45000 (45 seconds).",
+                ),
+            })
+            .catchall(
+              z.union([
+                z.object({
+                  disabled: z.literal(true),
+                }),
+                z.object({
+                  command: z.array(z.string()).optional(),
+                  extensions: z.array(z.string()).optional(),
+                  disabled: z.boolean().optional(),
+                  env: z.record(z.string(), z.string()).optional(),
+                  initialization: z.record(z.string(), z.any()).optional(),
+                  timeout: z
+                    .number()
+                    .int()
+                    .positive()
+                    .optional()
+                    .describe(
+                      "Timeout in milliseconds for this LSP server's initialization. Overrides global lsp.timeout.",
+                    ),
+                }),
+              ]),
+            ),
         ])
         .optional()
         .refine(
@@ -900,6 +918,8 @@ export namespace Config {
             const serverIds = new Set(Object.values(LSPServer).map((s) => s.id))
 
             return Object.entries(data).every(([id, config]) => {
+              if (id === "timeout") return true
+              if (typeof config !== "object") return false
               if (config.disabled) return true
               if (serverIds.has(id)) return true
               return Boolean(config.extensions)

packages/opencode/src/lsp/client.ts

@@ -8,6 +8,7 @@ import { Log } from "../util/log"
 import { LANGUAGE_EXTENSIONS } from "./language"
 import z from "zod"
 import type { LSPServer } from "./server"
+import { LSP } from "./index"
 import { NamedError } from "@opencode-ai/util/error"
 import { withTimeout } from "../util/timeout"
 import { Instance } from "../project/instance"
@@ -39,7 +40,7 @@ export namespace LSPClient {
     ),
   }
 
-  export async function create(input: { serverID: string; server: LSPServer.Handle; root: string }) {
+  export async function create(input: { serverID: string; server: LSPServer.Handle; root: string; timeout?: number }) {
     const l = log.clone().tag("serverID", input.serverID)
     l.info("starting client")
 
@@ -113,7 +114,7 @@ export namespace LSPClient {
           },
         },
       }),
-      45_000,
+      input.timeout ?? LSP.DEFAULT_LSP_TIMEOUT,
     ).catch((err) => {
       l.error("initialize error", { error: err })
       throw new InitializeError(

packages/opencode/src/lsp/index.ts

@@ -14,6 +14,8 @@ import { Flag } from "@/flag/flag"
 export namespace LSP {
   const log = Log.create({ service: "lsp" })
 
+  export const DEFAULT_LSP_TIMEOUT = 45_000
+
   export const Event = {
     Updated: BusEvent.define("lsp.updated", z.object({})),
   }
@@ -89,30 +91,57 @@ export namespace LSP {
           servers,
           clients,
           spawning: new Map<string, Promise<LSPClient.Info | undefined>>(),
+          globalTimeout: DEFAULT_LSP_TIMEOUT,
         }
       }
 
+      const globalTimeout = typeof cfg.lsp === "object" && cfg.lsp?.timeout ? cfg.lsp.timeout : DEFAULT_LSP_TIMEOUT
+      if (globalTimeout !== DEFAULT_LSP_TIMEOUT) {
+        log.info("LSP timeout overridden", { timeout: globalTimeout, default: DEFAULT_LSP_TIMEOUT })
+      }
+
       for (const server of Object.values(LSPServer)) {
         servers[server.id] = server
       }
 
       filterExperimentalServers(servers)
 
       for (const [name, item] of Object.entries(cfg.lsp ?? {})) {
+        // Skip 'timeout' key since it's a global config option, not a server definition
+        if (name === "timeout") continue
+        if (typeof item !== "object") continue
         const existing = servers[name]
         if (item.disabled) {
           log.info(`LSP server ${name} is disabled`)
           delete servers[name]
           continue
         }
+
+        if (!item.command) {
+          // No command = built-in server override
+          if (!existing) {
+            log.error(`LSP server ${name} not found. Custom servers require 'command' array.`)
+            continue
+          }
+
+          // Apply overrides to built-in server
+          servers[name] = {
+            ...existing,
+            ...(item.timeout !== undefined && { timeout: item.timeout }),
+          }
+          continue
+        }
+
+        const command = item.command
         servers[name] = {
           ...existing,
           id: name,
           root: existing?.root ?? (async () => Instance.directory),
           extensions: item.extensions ?? existing?.extensions ?? [],
+          timeout: item.timeout ?? existing?.timeout,
           spawn: async (root) => {
             return {
-              process: spawn(item.command[0], item.command.slice(1), {
+              process: spawn(command[0], command.slice(1), {
                 cwd: root,
                 env: {
                   ...process.env,
@@ -136,6 +165,7 @@ export namespace LSP {
         servers,
         clients,
         spawning: new Map<string, Promise<LSPClient.Info | undefined>>(),
+        globalTimeout,
       }
     },
     async (state) => {
@@ -195,10 +225,20 @@ export namespace LSP {
       if (!handle) return undefined
       log.info("spawned lsp server", { serverID: server.id })
 
+      const timeout = server.timeout ?? s.globalTimeout
+      if (server.timeout !== undefined) {
+        log.info("LSP server timeout overridden", {
+          serverID: server.id,
+          timeout: server.timeout,
+          globalTimeout: s.globalTimeout,
+        })
+      }
+
       const client = await LSPClient.create({
         serverID: server.id,
         server: handle,
         root,
+        timeout,
       }).catch((err) => {
         s.broken.add(key)
         handle.process.kill()

packages/opencode/src/lsp/server.ts

@@ -51,6 +51,7 @@ export namespace LSPServer {
     global?: boolean
     root: RootFunction
     spawn(root: string): Promise<Handle | undefined>
+    timeout?: number
   }
 
   export const Deno: Info = {