sqlmesh 0.189.3.dev9__tar.gz → 0.189.3.dev11__tar.gz

{sqlmesh-0.189.3.dev9 → sqlmesh-0.189.3.dev11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlmesh
-Version: 0.189.3.dev9
+Version: 0.189.3.dev11
 Summary: Next-generation data transformation framework
 Author-email: "TobikoData Inc." <engineering@tobikodata.com>
 License:                                  Apache License

{sqlmesh-0.189.3.dev9 → sqlmesh-0.189.3.dev11}/sqlmesh/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.189.3.dev9'
-__version_tuple__ = version_tuple = (0, 189, 3, 'dev9')
+__version__ = version = '0.189.3.dev11'
+__version_tuple__ = version_tuple = (0, 189, 3, 'dev11')

{sqlmesh-0.189.3.dev9 → sqlmesh-0.189.3.dev11}/sqlmesh/lsp/custom.py

@@ -72,3 +72,49 @@ class AllModelsForRenderResponse(PydanticModel):
     """
 
     models: t.List[ModelForRendering]
+
+
+SUPPORTED_METHODS_FEATURE = "sqlmesh/supported_methods"
+
+
+class SupportedMethodsRequest(PydanticModel):
+    """
+    Request to get all supported custom LSP methods.
+    """
+
+    pass
+
+
+class CustomMethod(PydanticModel):
+    """
+    Information about a custom LSP method.
+    """
+
+    name: str
+
+
+class SupportedMethodsResponse(PydanticModel):
+    """
+    Response containing all supported custom LSP methods.
+    """
+
+    methods: t.List[CustomMethod]
+
+
+FORMAT_PROJECT_FEATURE = "sqlmesh/format_project"
+
+
+class FormatProjectRequest(PydanticModel):
+    """
+    Request to format all models in the current project.
+    """
+
+    pass
+
+
+class FormatProjectResponse(PydanticModel):
+    """
+    Response to format project request.
+    """
+
+    pass

{sqlmesh-0.189.3.dev9 → sqlmesh-0.189.3.dev11}/sqlmesh/lsp/main.py

@@ -29,12 +29,19 @@ from sqlmesh.lsp.custom import (
     ALL_MODELS_FEATURE,
     ALL_MODELS_FOR_RENDER_FEATURE,
     RENDER_MODEL_FEATURE,
+    SUPPORTED_METHODS_FEATURE,
+    FORMAT_PROJECT_FEATURE,
     AllModelsRequest,
     AllModelsResponse,
     AllModelsForRenderRequest,
     AllModelsForRenderResponse,
     RenderModelRequest,
     RenderModelResponse,
+    SupportedMethodsRequest,
+    SupportedMethodsResponse,
+    FormatProjectRequest,
+    FormatProjectResponse,
+    CustomMethod,
 )
 from sqlmesh.lsp.hints import get_hints
 from sqlmesh.lsp.reference import get_references, get_cte_references
@@ -42,6 +49,15 @@ from sqlmesh.lsp.uri import URI
 from web.server.api.endpoints.lineage import column_lineage, model_lineage
 from web.server.api.endpoints.models import get_models
 
+SUPPORTED_CUSTOM_METHODS = [
+    ALL_MODELS_FEATURE,
+    RENDER_MODEL_FEATURE,
+    ALL_MODELS_FOR_RENDER_FEATURE,
+    API_FEATURE,
+    SUPPORTED_METHODS_FEATURE,
+    FORMAT_PROJECT_FEATURE,
+]
+
 
 class SQLMeshLanguageServer:
     def __init__(
@@ -149,6 +165,39 @@ class SQLMeshLanguageServer:
                 models=self.lsp_context.list_of_models_for_rendering()
             )
 
+        @self.server.feature(SUPPORTED_METHODS_FEATURE)
+        def supported_methods(
+            ls: LanguageServer, params: SupportedMethodsRequest
+        ) -> SupportedMethodsResponse:
+            """Return all supported custom LSP methods."""
+            return SupportedMethodsResponse(
+                methods=[
+                    CustomMethod(
+                        name=name,
+                    )
+                    for name in SUPPORTED_CUSTOM_METHODS
+                ]
+            )
+
+        @self.server.feature(FORMAT_PROJECT_FEATURE)
+        def format_project(
+            ls: LanguageServer, params: FormatProjectRequest
+        ) -> FormatProjectResponse:
+            """Format all models in the current project."""
+            try:
+                if self.lsp_context is None:
+                    current_path = Path.cwd()
+                    self._ensure_context_in_folder(current_path)
+                if self.lsp_context is None:
+                    raise RuntimeError("No context found")
+
+                # Call the format method on the context
+                self.lsp_context.context.format()
+                return FormatProjectResponse()
+            except Exception as e:
+                ls.log_trace(f"Error formatting project: {e}")
+                return FormatProjectResponse()
+
         @self.server.feature(API_FEATURE)
         def api(ls: LanguageServer, request: ApiRequest) -> t.Dict[str, t.Any]:
             ls.log_trace(f"API request: {request}")

{sqlmesh-0.189.3.dev9 → sqlmesh-0.189.3.dev11}/sqlmesh.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlmesh
-Version: 0.189.3.dev9
+Version: 0.189.3.dev11
 Summary: Next-generation data transformation framework
 Author-email: "TobikoData Inc." <engineering@tobikodata.com>
 License:                                  Apache License

{sqlmesh-0.189.3.dev9 → sqlmesh-0.189.3.dev11}/sqlmesh.egg-info/SOURCES.txt

@@ -731,6 +731,7 @@ vscode/extension/src/webviews/lineagePanel.ts
 vscode/extension/tests/completions.spec.ts
 vscode/extension/tests/diagnostics.spec.ts
 vscode/extension/tests/find_references.spec.ts
+vscode/extension/tests/format.spec.ts
 vscode/extension/tests/go_to_definition.spec.ts
 vscode/extension/tests/hints.spec.ts
 vscode/extension/tests/lineage.spec.ts
@@ -814,50 +815,50 @@ web/client/tailwind.config.cjs
 web/client/tsconfig.json
 web/client/vite.config.ts
 web/client/dist/index.html
-web/client/dist/assets/Audits-DB1HcP9M.js
-web/client/dist/assets/Banner-DNY__4sG.js
-web/client/dist/assets/ChevronDownIcon-lHn9zjvd.js
-web/client/dist/assets/ChevronRightIcon-oQ5f5ZGP.js
-web/client/dist/assets/Content-Da0wstVW.js
-web/client/dist/assets/Content-QpBh5BIf.js
-web/client/dist/assets/Data-C7p96ruh.js
-web/client/dist/assets/DataCatalog-C7cUGv8x.js
-web/client/dist/assets/Editor-B6PRl__L.js
-web/client/dist/assets/Editor-S5kDO3v1.js
-web/client/dist/assets/Errors-CxCutNFm.js
-web/client/dist/assets/FileExplorer-kP-IjmYP.js
-web/client/dist/assets/Footer-rRlYYZGX.js
-web/client/dist/assets/Header-DWsJQ7Zd.js
-web/client/dist/assets/Input-DdPN19Px.js
-web/client/dist/assets/Lineage-BQJPyHVL.js
-web/client/dist/assets/ListboxShow-BmQk-sC6.js
-web/client/dist/assets/ModelLineage-Cb-ryU8k.js
-web/client/dist/assets/Models-Bv0YKo6C.js
-web/client/dist/assets/Page-C-F04Qw-.js
-web/client/dist/assets/Plan-DfF6_rdE.js
-web/client/dist/assets/PlusCircleIcon-D8BJTuwF.js
-web/client/dist/assets/ReportErrors-BR3yV5Ru.js
-web/client/dist/assets/Root-gCyYAZOq.js
-web/client/dist/assets/SearchList-Mw4DP7x1.js
-web/client/dist/assets/SelectEnvironment-C-I8dl8g.js
-web/client/dist/assets/SourceList-nJbKxW-u.js
-web/client/dist/assets/SourceListItem-Cpx6p_wh.js
-web/client/dist/assets/SplitPane-CwtTNpO8.js
-web/client/dist/assets/Tests-BKeeabY_.js
-web/client/dist/assets/Welcome-D191sGJC.js
+web/client/dist/assets/Audits-Bvr7M5Cg.js
+web/client/dist/assets/Banner-B_rJvh8O.js
+web/client/dist/assets/ChevronDownIcon-SZg7zD3B.js
+web/client/dist/assets/ChevronRightIcon-BGlTDFlW.js
+web/client/dist/assets/Content-BX5bHEIM.js
+web/client/dist/assets/Content-DuTflNnu.js
+web/client/dist/assets/Data--_LvHKB5.js
+web/client/dist/assets/DataCatalog-CDUa7UBO.js
+web/client/dist/assets/Editor---NX-EOB.js
+web/client/dist/assets/Editor-ClU6zMcH.js
+web/client/dist/assets/Errors-lzXHPiom.js
+web/client/dist/assets/FileExplorer-CB7x6Zt5.js
+web/client/dist/assets/Footer-C0X7AnA5.js
+web/client/dist/assets/Header-T0redAYU.js
+web/client/dist/assets/Input-BQqcM0yt.js
+web/client/dist/assets/Lineage-Z_rKyQjf.js
+web/client/dist/assets/ListboxShow-DrRCf9sL.js
+web/client/dist/assets/ModelLineage-DC1kbGVO.js
+web/client/dist/assets/Models-nG2g7q6-.js
+web/client/dist/assets/Page-BQKUIqng.js
+web/client/dist/assets/Plan-C0T4Faqg.js
+web/client/dist/assets/PlusCircleIcon-BDES6aDU.js
+web/client/dist/assets/ReportErrors-Cuv4D77y.js
+web/client/dist/assets/Root-q1MHWtlB.js
+web/client/dist/assets/SearchList-BU76SGzL.js
+web/client/dist/assets/SelectEnvironment-BtI6wkY7.js
+web/client/dist/assets/SourceList-C1RxJTpZ.js
+web/client/dist/assets/SourceListItem-BTqd6jLB.js
+web/client/dist/assets/SplitPane-zgn_nUAw.js
+web/client/dist/assets/Tests-CK6uzr59.js
+web/client/dist/assets/Welcome-DKlRE9Lt.js
 web/client/dist/assets/_commonjs-dynamic-modules-TDtrdbi3.js
-web/client/dist/assets/context-5PbIKqqT.js
-web/client/dist/assets/context-CVkhr9QB.js
-web/client/dist/assets/editor-DWINdd81.js
-web/client/dist/assets/file-e9qyDfWg.js
-web/client/dist/assets/floating-ui.react-dom-B-NNWGkz.js
+web/client/dist/assets/context-CHLxBWS9.js
+web/client/dist/assets/context-CzXAuYu4.js
+web/client/dist/assets/editor-A537AE0N.js
+web/client/dist/assets/file-DfM1ePvm.js
+web/client/dist/assets/floating-ui.react-dom-DhdjjAk5.js
 web/client/dist/assets/help-6Q7f7fjd.js
-web/client/dist/assets/help-CjbSQwWi.js
-web/client/dist/assets/index-BZGZqBUO.js
-web/client/dist/assets/index-BkNpRAHt.js
-web/client/dist/assets/plan-C2UHjG7p.js
-web/client/dist/assets/popover-C8e3ENo3.js
-web/client/dist/assets/project-BDZ1fnja.js
+web/client/dist/assets/help-DtSFwTCR.js
+web/client/dist/assets/index-BBxFj1Oj.js
+web/client/dist/assets/index-DvOWtL0R.js
+web/client/dist/assets/plan-Bm6MqEdG.js
+web/client/dist/assets/popover-nHJ-KXbz.js
+web/client/dist/assets/project-B1HtWBfw.js
 web/client/dist/css/base.css
 web/client/dist/css/design.css
 web/client/dist/favicons/favicon.svg

{sqlmesh-0.189.3.dev9 → sqlmesh-0.189.3.dev11}/vscode/extension/src/commands/format.ts

@@ -5,19 +5,45 @@ import * as vscode from 'vscode'
 import { ErrorType, handleError } from '../utilities/errors'
 import { AuthenticationProviderTobikoCloud } from '../auth/auth'
 import { execAsync } from '../utilities/exec'
+import { LSPClient } from '../lsp/lsp'
 
 export const format =
-  (authProvider: AuthenticationProviderTobikoCloud) =>
+  (
+    authProvider: AuthenticationProviderTobikoCloud,
+    lsp: LSPClient | undefined,
+  ) =>
   async (): Promise<void> => {
     traceLog('Calling format')
-    const out = await internalFormat()
+    const out = await internalFormat(lsp)
     if (isErr(out)) {
       return handleError(authProvider, out.error, 'Project format failed')
     }
     vscode.window.showInformationMessage('Project formatted successfully')
   }
 
-const internalFormat = async (): Promise<Result<undefined, ErrorType>> => {
+const internalFormat = async (
+  lsp: LSPClient | undefined,
+): Promise<Result<undefined, ErrorType>> => {
+  try {
+    // Try LSP method first
+    if (lsp) {
+      const response = await lsp.call_custom_method(
+        'sqlmesh/format_project',
+        {},
+      )
+      if (isErr(response)) {
+        return response
+      }
+      return ok(undefined)
+    }
+  } catch (error) {
+    traceLog(`LSP format failed, falling back to CLI: ${JSON.stringify(error)}`)
+  }
+
+  // Fallback to CLI method if LSP is not available
+  // TODO This is a solution in order to be backwards compatible in the cases
+  //  where the LSP method is not implemented yet. This should be removed at
+  //  some point in the future.
   const exec = await sqlmeshExec()
   if (isErr(exec)) {
     return exec

{sqlmesh-0.189.3.dev9 → sqlmesh-0.189.3.dev11}/vscode/extension/src/commands/renderModel.ts

@@ -73,7 +73,7 @@ export function renderModel(
 
       if (isErr(allModelsResult)) {
         vscode.window.showErrorMessage(
-          `Failed to get models: ${allModelsResult.error}`,
+          `Failed to get models: ${allModelsResult.error.message}`,
         )
         return
       }
@@ -115,7 +115,9 @@ export function renderModel(
     })
 
     if (isErr(result)) {
-      vscode.window.showErrorMessage(`Failed to render model: ${result.error}`)
+      vscode.window.showErrorMessage(
+        `Failed to render model: ${result.error.message}`,
+      )
       return
     }
 

{sqlmesh-0.189.3.dev9 → sqlmesh-0.189.3.dev11}/vscode/extension/src/extension.ts

@@ -56,9 +56,6 @@ export async function activate(context: vscode.ExtensionContext) {
   context.subscriptions.push(
     vscode.commands.registerCommand('sqlmesh.signout', signOut(authProvider)),
   )
-  context.subscriptions.push(
-    vscode.commands.registerCommand('sqlmesh.format', format(authProvider)),
-  )
 
   lspClient = new LSPClient()
 
@@ -79,6 +76,13 @@ export async function activate(context: vscode.ExtensionContext) {
     ),
   )
 
+  context.subscriptions.push(
+    vscode.commands.registerCommand(
+      'sqlmesh.format',
+      format(authProvider, lspClient),
+    ),
+  )
+
   // Register the webview
   const lineagePanel = new LineagePanel(context.extensionUri, lspClient)
   context.subscriptions.push(

{sqlmesh-0.189.3.dev9 → sqlmesh-0.189.3.dev11}/vscode/extension/src/lsp/custom.ts

@@ -31,6 +31,8 @@ export type CustomLSPMethods =
   | AbstractAPICall
   | RenderModelMethod
   | AllModelsForRenderMethod
+  | SupportedMethodsMethod
+  | FormatProjectMethod
 
 interface AllModelsRequest {
   textDocument: {
@@ -75,3 +77,32 @@ export interface ModelForRendering {
   description: string | null | undefined
   uri: string
 }
+
+export interface SupportedMethodsMethod {
+  method: 'sqlmesh/supported_methods'
+  request: SupportedMethodsRequest
+  response: SupportedMethodsResponse
+}
+
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+interface SupportedMethodsRequest {}
+
+interface SupportedMethodsResponse {
+  methods: CustomMethod[]
+}
+
+interface CustomMethod {
+  name: string
+}
+
+export interface FormatProjectMethod {
+  method: 'sqlmesh/format_project'
+  request: FormatProjectRequest
+  response: FormatProjectResponse
+}
+
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+interface FormatProjectRequest {}
+
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+interface FormatProjectResponse {}

sqlmesh-0.189.3.dev11/vscode/extension/src/lsp/lsp.ts

@@ -0,0 +1,251 @@
+import { window, OutputChannel, Disposable } from 'vscode'
+import {
+  ServerOptions,
+  LanguageClientOptions,
+  LanguageClient,
+  TransportKind,
+} from 'vscode-languageclient/node'
+import { sqlmeshLspExec } from '../utilities/sqlmesh/sqlmesh'
+import { err, isErr, ok, Result } from '@bus/result'
+import { getWorkspaceFolders } from '../utilities/common/vscodeapi'
+import { traceError, traceInfo } from '../utilities/common/log'
+import {
+  ErrorType,
+  ErrorTypeGeneric,
+  ErrorTypeInvalidState,
+  ErrorTypeSQLMeshOutdated,
+} from '../utilities/errors'
+import { CustomLSPMethods } from './custom'
+
+type SupportedMethodsState =
+  | { type: 'not-fetched' }
+  | { type: 'fetched'; methods: Set<string> }
+  // TODO: This state is used when the `sqlmesh/supported_methods` endpoint is
+  //  not supported by the LSP server. This is in order to be backward compatible
+  //  with older versions of SQLMesh that do not support this endpoint. At some point
+  //  we should remove this state and always fetch the supported methods.
+  | { type: 'endpoint-not-supported' }
+
+let outputChannel: OutputChannel | undefined
+
+export class LSPClient implements Disposable {
+  private client: LanguageClient | undefined
+  /**
+   * State to track whether the supported methods have been fetched. These are used to determine if a method is supported
+   * by the LSP server and return an error if not.
+   */
+  private supportedMethodsState: SupportedMethodsState = { type: 'not-fetched' }
+
+  constructor() {
+    this.client = undefined
+  }
+
+  // TODO: This method is used to check if the LSP client has completion capability
+  //  in order to be backward compatible with older versions of SQLMesh that do not
+  //  support completion. At some point we should remove this method and always assume
+  //  that the LSP client has completion capability.
+  public hasCompletionCapability(): boolean {
+    if (!this.client) {
+      traceError('LSP client is not initialized')
+      return false
+    }
+    const capabilities = this.client.initializeResult?.capabilities
+    const completion = capabilities?.completionProvider
+    return completion !== undefined
+  }
+
+  public async start(): Promise<Result<undefined, ErrorType>> {
+    if (!outputChannel) {
+      outputChannel = window.createOutputChannel('sqlmesh-lsp')
+    }
+
+    const sqlmesh = await sqlmeshLspExec()
+    if (isErr(sqlmesh)) {
+      traceError(
+        `Failed to get sqlmesh_lsp_exec, ${JSON.stringify(sqlmesh.error)}`,
+      )
+      return sqlmesh
+    }
+    const workspaceFolders = getWorkspaceFolders()
+    if (workspaceFolders.length === 0) {
+      traceError(`No workspace folders found`)
+      return err({
+        type: 'generic',
+        message: 'No workspace folders found',
+      })
+    }
+    const workspacePath = sqlmesh.value.workspacePath
+    const serverOptions: ServerOptions = {
+      run: {
+        command: sqlmesh.value.bin,
+        transport: TransportKind.stdio,
+        options: {
+          cwd: workspacePath,
+        },
+        args: sqlmesh.value.args,
+      },
+      debug: {
+        command: sqlmesh.value.bin,
+        transport: TransportKind.stdio,
+        options: {
+          cwd: workspacePath,
+        },
+        args: sqlmesh.value.args,
+      },
+    }
+    const clientOptions: LanguageClientOptions = {
+      documentSelector: [{ scheme: 'file', pattern: `**/*.sql` }],
+      diagnosticCollectionName: 'sqlmesh',
+      outputChannel: outputChannel,
+    }
+
+    traceInfo(
+      `Starting SQLMesh Language Server with workspace path: ${workspacePath} with server options ${JSON.stringify(serverOptions)} and client options ${JSON.stringify(clientOptions)}`,
+    )
+    this.client = new LanguageClient(
+      'sqlmesh-lsp',
+      'SQLMesh Language Server',
+      serverOptions,
+      clientOptions,
+    )
+    await this.client.start()
+    return ok(undefined)
+  }
+
+  public async restart(): Promise<Result<undefined, ErrorType>> {
+    await this.stop()
+    return await this.start()
+  }
+
+  public async stop() {
+    if (this.client) {
+      await this.client.stop()
+      this.client = undefined
+      // Reset supported methods state when the client stops
+      this.supportedMethodsState = { type: 'not-fetched' }
+    }
+  }
+
+  public async dispose() {
+    await this.stop()
+  }
+
+  private async fetchSupportedMethods(): Promise<void> {
+    if (!this.client || this.supportedMethodsState.type !== 'not-fetched') {
+      return
+    }
+    try {
+      const result = await this.internal_call_custom_method(
+        'sqlmesh/supported_methods',
+        {},
+      )
+      if (isErr(result)) {
+        traceError(`Failed to fetch supported methods: ${result.error}`)
+        this.supportedMethodsState = { type: 'endpoint-not-supported' }
+        return
+      }
+      const methodNames = new Set(result.value.methods.map(m => m.name))
+      this.supportedMethodsState = { type: 'fetched', methods: methodNames }
+      traceInfo(
+        `Fetched supported methods: ${Array.from(methodNames).join(', ')}`,
+      )
+    } catch {
+      // If the supported_methods endpoint doesn't exist, mark it as not supported
+      this.supportedMethodsState = { type: 'endpoint-not-supported' }
+      traceInfo(
+        'Supported methods endpoint not available, proceeding without validation',
+      )
+    }
+  }
+
+  public async call_custom_method<
+    Method extends Exclude<
+      CustomLSPMethods['method'],
+      'sqlmesh/supported_methods'
+    >,
+    Request extends Extract<CustomLSPMethods, { method: Method }>['request'],
+    Response extends Extract<CustomLSPMethods, { method: Method }>['response'],
+  >(
+    method: Method,
+    request: Request,
+  ): Promise<
+    Result<
+      Response,
+      ErrorTypeGeneric | ErrorTypeInvalidState | ErrorTypeSQLMeshOutdated
+    >
+  > {
+    if (!this.client) {
+      return err({
+        type: 'generic',
+        message: 'LSP client not ready.',
+      })
+    }
+    await this.fetchSupportedMethods()
+
+    const supportedState = this.supportedMethodsState
+    switch (supportedState.type) {
+      case 'not-fetched':
+        return err({
+          type: 'invalid_state',
+          message: 'Supported methods not fetched yet whereas they should.',
+        })
+      case 'fetched': {
+        // If we have fetched the supported methods, we can check if the method is supported
+        if (!supportedState.methods.has(method)) {
+          return err({
+            type: 'sqlmesh_outdated',
+            message: `Method '${method}' is not supported by this LSP server.`,
+          })
+        }
+        const response = await this.internal_call_custom_method(
+          method,
+          request as any,
+        )
+        if (isErr(response)) {
+          return err({
+            type: 'generic',
+            message: response.error,
+          })
+        }
+        return ok(response.value as Response)
+      }
+      case 'endpoint-not-supported': {
+        const response = await this.internal_call_custom_method(
+          method,
+          request as any,
+        )
+        if (isErr(response)) {
+          return err({
+            type: 'generic',
+            message: response.error,
+          })
+        }
+        return ok(response.value as Response)
+      }
+    }
+  }
+
+  /**
+   * Internal method to call a custom LSP method without checking if the method is supported. It is used for
+   * the class whereas the `call_custom_method` checks if the method is supported.
+   */
+  public async internal_call_custom_method<
+    Method extends CustomLSPMethods['method'],
+    Request extends Extract<CustomLSPMethods, { method: Method }>['request'],
+    Response extends Extract<CustomLSPMethods, { method: Method }>['response'],
+  >(method: Method, request: Request): Promise<Result<Response, string>> {
+    if (!this.client) {
+      return err('lsp client not ready')
+    }
+
+    try {
+      const result = await this.client.sendRequest<Response>(method, request)
+      return ok(result)
+    } catch (error) {
+      traceError(
+        `lsp '${method}' request ${JSON.stringify(request)} failed: ${JSON.stringify(error)}`,
+      )
+      return err(JSON.stringify(error))
+    }
+  }
+}