feat: :sparkles: LSP connection over websockets

7 files changed, 274 insertions, 890 deletions

diff --git a/continuedev/src/continuedev/core/lsp.py b/continuedev/src/continuedev/core/lsp.py
index 86923fb7..181eea2e 100644
--- a/continuedev/src/continuedev/core/lsp.py
+++ b/continuedev/src/continuedev/core/lsp.py
@@ -1,282 +1,272 @@
 import asyncio
-import os
-import socket
-import subprocess
 import threading
 from typing import List, Optional
 
+import aiohttp
 from pydantic import BaseModel
-from pylsp.python_lsp import PythonLSPServer, start_tcp_lang_server
+from pylsp.python_lsp import PythonLSPServer, start_ws_lang_server
 
-from ..libs.lspclient.json_rpc_endpoint import JsonRpcEndpoint
-from ..libs.lspclient.lsp_client import LspClient
-from ..libs.lspclient.lsp_endpoint import LspEndpoint
-from ..libs.lspclient.lsp_structs import Position as LspPosition
-from ..libs.lspclient.lsp_structs import SymbolInformation, TextDocumentIdentifier
 from ..libs.util.logging import logger
 from ..models.filesystem import RangeInFile
 from ..models.main import Position, Range
 
 
-class ReadPipe(threading.Thread):
-    def __init__(self, pipe):
-        threading.Thread.__init__(self)
-        self.pipe = pipe
-
-    def run(self):
-        line = self.pipe.readline().decode("utf-8")
-        while line:
-            print(line)
-            line = self.pipe.readline().decode("utf-8")
+def filepath_to_uri(filename: str) -> str:
+    return f"file://{filename}"
 
 
-class SocketFileWrapper:
-    def __init__(self, sockfile):
-        self.sockfile = sockfile
+def uri_to_filepath(uri: str) -> str:
+    if uri.startswith("file://"):
+        return uri.lstrip("file://")
+    else:
+        return uri
 
-    def write(self, data):
-        if isinstance(data, bytes):
-            data = data.decode("utf-8").replace("\r\n", "\n")
-        return self.sockfile.write(data)
 
-    def read(self, size=-1):
-        data = self.sockfile.read(size)
-        if isinstance(data, str):
-            data = data.replace("\n", "\r\n").encode("utf-8")
-        return data
+PORT = 8099
 
-    def readline(self, size=-1):
-        data = self.sockfile.readline(size)
-        if isinstance(data, str):
-            data = data.replace("\n", "\r\n").encode("utf-8")
-        return data
 
-    def flush(self):
-        return self.sockfile.flush()
+class LSPClient:
+    def __init__(self, host: str, port: int, workspace_paths: List[str]):
+        self.host = host
+        self.port = port
+        self.session = aiohttp.ClientSession()
+        self.next_id = 0
+        self.workspace_paths = workspace_paths
 
-    def close(self):
-        return self.sockfile.close()
+    async def connect(self):
+        print("Connecting")
+        self.ws = await self.session.ws_connect(f"ws://{self.host}:{self.port}/")
+        print("Connected")
 
+    async def send(self, data):
+        await self.ws.send_json(data)
 
-async def create_json_rpc_endpoint(use_subprocess: Optional[str] = None):
-    if use_subprocess is None:
-        try:
-            threading.Thread(
-                target=start_tcp_lang_server,
-                args=("localhost", 8080, False, PythonLSPServer),
-            ).start()
-        except Exception as e:
-            logger.warning("Could not start TCP server: %s", e)
+    async def recv(self):
+        return await self.ws.receive_json()
 
-        await asyncio.sleep(2)
+    async def close(self):
+        await self.ws.close()
+        await self.session.close()
 
-        # Connect to the server
-        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        s.connect(("localhost", 8080))
+    async def call_method(self, method_name, **kwargs):
+        body = {
+            "jsonrpc": "2.0",
+            "id": self.next_id,
+            "method": method_name,
+            "params": kwargs,
+        }
+        self.next_id += 1
+        await self.send(body)
+        response = await self.recv()
+        return response
 
-        # Create a file-like object from the socket
-        sockfile = s.makefile("rw")
-        wrapped_sockfile = SocketFileWrapper(sockfile)
-        return JsonRpcEndpoint(wrapped_sockfile, wrapped_sockfile), None
+    async def initialize(self):
+        initialization_args = {
+            "capabilities": {
+                "textDocument": {
+                    "codeAction": {"dynamicRegistration": True},
+                    "codeLens": {"dynamicRegistration": True},
+                    "colorProvider": {"dynamicRegistration": True},
+                    "completion": {
+                        "completionItem": {
+                            "commitCharactersSupport": True,
+                            "documentationFormat": ["markdown", "plaintext"],
+                            "snippetSupport": True,
+                        },
+                        "completionItemKind": {
+                            "valueSet": [
+                                1,
+                                2,
+                                3,
+                                4,
+                                5,
+                                6,
+                                7,
+                                8,
+                                9,
+                                10,
+                                11,
+                                12,
+                                13,
+                                14,
+                                15,
+                                16,
+                                17,
+                                18,
+                                19,
+                                20,
+                                21,
+                                22,
+                                23,
+                                24,
+                                25,
+                            ]
+                        },
+                        "contextSupport": True,
+                        "dynamicRegistration": True,
+                    },
+                    "definition": {"dynamicRegistration": True},
+                    "documentHighlight": {"dynamicRegistration": True},
+                    "documentLink": {"dynamicRegistration": True},
+                    "documentSymbol": {
+                        "dynamicRegistration": True,
+                        "symbolKind": {
+                            "valueSet": [
+                                1,
+                                2,
+                                3,
+                                4,
+                                5,
+                                6,
+                                7,
+                                8,
+                                9,
+                                10,
+                                11,
+                                12,
+                                13,
+                                14,
+                                15,
+                                16,
+                                17,
+                                18,
+                                19,
+                                20,
+                                21,
+                                22,
+                                23,
+                                24,
+                                25,
+                                26,
+                            ]
+                        },
+                    },
+                    "formatting": {"dynamicRegistration": True},
+                    "hover": {
+                        "contentFormat": ["markdown", "plaintext"],
+                        "dynamicRegistration": True,
+                    },
+                    "implementation": {"dynamicRegistration": True},
+                    "onTypeFormatting": {"dynamicRegistration": True},
+                    "publishDiagnostics": {"relatedInformation": True},
+                    "rangeFormatting": {"dynamicRegistration": True},
+                    "references": {"dynamicRegistration": True},
+                    "rename": {"dynamicRegistration": True},
+                    "signatureHelp": {
+                        "dynamicRegistration": True,
+                        "signatureInformation": {
+                            "documentationFormat": ["markdown", "plaintext"]
+                        },
+                    },
+                    "synchronization": {
+                        "didSave": True,
+                        "dynamicRegistration": True,
+                        "willSave": True,
+                        "willSaveWaitUntil": True,
+                    },
+                    "typeDefinition": {"dynamicRegistration": True},
+                },
+                "workspace": {
+                    "applyEdit": True,
+                    "configuration": True,
+                    "didChangeConfiguration": {"dynamicRegistration": True},
+                    "didChangeWatchedFiles": {"dynamicRegistration": True},
+                    "executeCommand": {"dynamicRegistration": True},
+                    "symbol": {
+                        "dynamicRegistration": True,
+                        "symbolKind": {
+                            "valueSet": [
+                                1,
+                                2,
+                                3,
+                                4,
+                                5,
+                                6,
+                                7,
+                                8,
+                                9,
+                                10,
+                                11,
+                                12,
+                                13,
+                                14,
+                                15,
+                                16,
+                                17,
+                                18,
+                                19,
+                                20,
+                                21,
+                                22,
+                                23,
+                                24,
+                                25,
+                                26,
+                            ]
+                        },
+                    },
+                    "workspaceEdit": {"documentChanges": True},
+                    "workspaceFolders": True,
+                },
+            },
+            "processId": 1234,
+            "rootPath": None,
+            "rootUri": filepath_to_uri(self.workspace_paths[0]),
+            "initializationOptions": {},
+            "trace": "off",
+            "workspaceFolders": [
+                {
+                    "uri": filepath_to_uri(workspacePath),
+                    "name": workspacePath.split("/")[-1],
+                }
+                for workspacePath in self.workspace_paths
+            ],
+        }
+        return await self.call_method("initialize", **initialization_args)
+
+    async def goto_definition(self, filepath: str, position: Position):
+        return await self.call_method(
+            "textDocument/definition",
+            textDocument={"uri": filepath_to_uri(filepath)},
+            position=position.dict(),
+        )
 
-    else:
-        pyls_cmd = use_subprocess.split()
-        p = subprocess.Popen(
-            pyls_cmd,
-            stdin=subprocess.PIPE,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
+    async def document_symbol(self, filepath: str):
+        return await self.call_method(
+            "textDocument/documentSymbol",
+            textDocument={"uri": filepath_to_uri(filepath)},
         )
-        read_pipe = ReadPipe(p.stderr)
-        read_pipe.start()
-        return JsonRpcEndpoint(p.stdin, p.stdout), p
 
 
-def filename_to_uri(filename: str) -> str:
-    return f"file://{filename}"
+async def start_language_server() -> threading.Thread:
+    try:
+        thread = threading.Thread(
+            target=start_ws_lang_server,
+            args=(PORT, False, PythonLSPServer),
+        )
+        thread.daemon = True
+        thread.start()
 
+    except Exception as e:
+        logger.warning("Could not start TCP server: %s", e)
 
-def uri_to_filename(uri: str) -> str:
-    if uri.startswith("file://"):
-        return uri.lstrip("file://")
-    else:
-        return uri
+    await asyncio.sleep(2)
 
+    return thread
 
-async def create_lsp_client(workspace_dir: str, use_subprocess: Optional[str] = None):
-    json_rpc_endpoint, process = await create_json_rpc_endpoint(
-        use_subprocess=use_subprocess
-    )
-    lsp_endpoint = LspEndpoint(json_rpc_endpoint)
-    lsp_client = LspClient(lsp_endpoint)
-    capabilities = {
-        "textDocument": {
-            "codeAction": {"dynamicRegistration": True},
-            "codeLens": {"dynamicRegistration": True},
-            "colorProvider": {"dynamicRegistration": True},
-            "completion": {
-                "completionItem": {
-                    "commitCharactersSupport": True,
-                    "documentationFormat": ["markdown", "plaintext"],
-                    "snippetSupport": True,
-                },
-                "completionItemKind": {
-                    "valueSet": [
-                        1,
-                        2,
-                        3,
-                        4,
-                        5,
-                        6,
-                        7,
-                        8,
-                        9,
-                        10,
-                        11,
-                        12,
-                        13,
-                        14,
-                        15,
-                        16,
-                        17,
-                        18,
-                        19,
-                        20,
-                        21,
-                        22,
-                        23,
-                        24,
-                        25,
-                    ]
-                },
-                "contextSupport": True,
-                "dynamicRegistration": True,
-            },
-            "definition": {"dynamicRegistration": True},
-            "documentHighlight": {"dynamicRegistration": True},
-            "documentLink": {"dynamicRegistration": True},
-            "documentSymbol": {
-                "dynamicRegistration": True,
-                "symbolKind": {
-                    "valueSet": [
-                        1,
-                        2,
-                        3,
-                        4,
-                        5,
-                        6,
-                        7,
-                        8,
-                        9,
-                        10,
-                        11,
-                        12,
-                        13,
-                        14,
-                        15,
-                        16,
-                        17,
-                        18,
-                        19,
-                        20,
-                        21,
-                        22,
-                        23,
-                        24,
-                        25,
-                        26,
-                    ]
-                },
-            },
-            "formatting": {"dynamicRegistration": True},
-            "hover": {
-                "contentFormat": ["markdown", "plaintext"],
-                "dynamicRegistration": True,
-            },
-            "implementation": {"dynamicRegistration": True},
-            "onTypeFormatting": {"dynamicRegistration": True},
-            "publishDiagnostics": {"relatedInformation": True},
-            "rangeFormatting": {"dynamicRegistration": True},
-            "references": {"dynamicRegistration": True},
-            "rename": {"dynamicRegistration": True},
-            "signatureHelp": {
-                "dynamicRegistration": True,
-                "signatureInformation": {
-                    "documentationFormat": ["markdown", "plaintext"]
-                },
-            },
-            "synchronization": {
-                "didSave": True,
-                "dynamicRegistration": True,
-                "willSave": True,
-                "willSaveWaitUntil": True,
-            },
-            "typeDefinition": {"dynamicRegistration": True},
-        },
-        "workspace": {
-            "applyEdit": True,
-            "configuration": True,
-            "didChangeConfiguration": {"dynamicRegistration": True},
-            "didChangeWatchedFiles": {"dynamicRegistration": True},
-            "executeCommand": {"dynamicRegistration": True},
-            "symbol": {
-                "dynamicRegistration": True,
-                "symbolKind": {
-                    "valueSet": [
-                        1,
-                        2,
-                        3,
-                        4,
-                        5,
-                        6,
-                        7,
-                        8,
-                        9,
-                        10,
-                        11,
-                        12,
-                        13,
-                        14,
-                        15,
-                        16,
-                        17,
-                        18,
-                        19,
-                        20,
-                        21,
-                        22,
-                        23,
-                        24,
-                        25,
-                        26,
-                    ]
-                },
-            },
-            "workspaceEdit": {"documentChanges": True},
-            "workspaceFolders": True,
-        },
-    }
-    root_uri = filename_to_uri(workspace_dir)
-    dir_name = os.path.basename(workspace_dir)
-    workspace_folders = [{"name": dir_name, "uri": root_uri}]
-    lsp_client.initialize(
-        None,
-        None,
-        root_uri,
-        None,
-        capabilities,
-        "off",
-        workspace_folders,
-    )
-    lsp_client.initialized()
-    return lsp_client, process
+
+class DocumentSymbol(BaseModel):
+    name: str
+    containerName: Optional[str] = None
+    kind: int
+    location: RangeInFile
 
 
 class ContinueLSPClient(BaseModel):
     workspace_dir: str
-    lsp_client: LspClient = None
-    use_subprocess: Optional[str] = None
-    lsp_process: Optional[subprocess.Popen] = None
+
+    lsp_client: LSPClient = None
+    lsp_thread: Optional[threading.Thread] = None
 
     class Config:
         arbitrary_types_allowed = True
@@ -287,26 +277,26 @@ class ContinueLSPClient(BaseModel):
         return original_dict
 
     async def start(self):
-        self.lsp_client, self.lsp_process = await create_lsp_client(
-            self.workspace_dir, use_subprocess=self.use_subprocess
-        )
+        self.lsp_thread = await start_language_server()
+        self.lsp_client = LSPClient("localhost", PORT, [self.workspace_dir])
+        await self.lsp_client.connect()
+        await self.lsp_client.initialize()
 
     async def stop(self):
-        self.lsp_client.shutdown()
-        self.lsp_client.exit()
-        if self.lsp_process is not None:
-            self.lsp_process.terminate()
-            self.lsp_process.wait()
-            self.lsp_process = None
-
-    def goto_definition(self, position: Position, filename: str) -> List[RangeInFile]:
-        response = self.lsp_client.definition(
-            TextDocumentIdentifier(filename_to_uri(filename)),
-            LspPosition(position.line, position.character),
+        await self.lsp_client.close()
+        if self.lsp_thread:
+            self.lsp_thread.join()
+
+    async def goto_definition(
+        self, position: Position, filename: str
+    ) -> List[RangeInFile]:
+        response = self.lsp_client.goto_definition(
+            filename,
+            position,
         )
         return [
             RangeInFile(
-                filepath=uri_to_filename(x.uri),
+                filepath=uri_to_filepath(x.uri),
                 range=Range.from_shorthand(
                     x.range.start.line,
                     x.range.start.character,
@@ -317,9 +307,22 @@ class ContinueLSPClient(BaseModel):
             for x in response
         ]
 
-    def get_symbols(self, filepath: str) -> List[SymbolInformation]:
-        response = self.lsp_client.documentSymbol(
-            TextDocumentIdentifier(filename_to_uri(filepath))
-        )
-
-        return response
+    async def document_symbol(self, filepath: str) -> List:
+        response = await self.lsp_client.document_symbol(filepath)
+        return [
+            DocumentSymbol(
+                name=x["name"],
+                containerName=x["containerName"],
+                kind=x["kind"],
+                location=RangeInFile(
+                    filepath=uri_to_filepath(x["location"]["uri"]),
+                    range=Range.from_shorthand(
+                        x["location"]["range"]["start"]["line"],
+                        x["location"]["range"]["start"]["character"],
+                        x["location"]["range"]["end"]["line"],
+                        x["location"]["range"]["end"]["character"],
+                    ),
+                ),
+            )
+            for x in response["result"]
+        ]
diff --git a/continuedev/src/continuedev/core/sdk.py b/continuedev/src/continuedev/core/sdk.py
index 658848c8..de209114 100644
--- a/continuedev/src/continuedev/core/sdk.py
+++ b/continuedev/src/continuedev/core/sdk.py
@@ -2,6 +2,8 @@ import os
 import traceback
 from typing import Coroutine, List, Optional, Union
 
+from ..libs.util.create_async_task import create_async_task
+
 from ..libs.llm import LLM
 from ..libs.util.devdata import dev_data_logger
 from ..libs.util.logging import logger
@@ -103,9 +105,9 @@ class ContinueSDK(AbstractContinueSDK):
                 logger.warning(f"Failed to start LSP client: {e}", exc_info=True)
                 sdk.lsp = None
 
-        # create_async_task(
-        #     start_lsp(), on_error=lambda e: logger.error("Failed to setup LSP: %s", e)
-        # )
+        create_async_task(
+            start_lsp(), on_error=lambda e: logger.error("Failed to setup LSP: %s", e)
+        )
 
         # When the config is loaded, setup posthog logger
         posthog_logger.setup(sdk.ide.unique_id, sdk.config.allow_anonymous_telemetry)
diff --git a/continuedev/src/continuedev/libs/lspclient/json_rpc_endpoint.py b/continuedev/src/continuedev/libs/lspclient/json_rpc_endpoint.py
deleted file mode 100644
index 80c51000..00000000
--- a/continuedev/src/continuedev/libs/lspclient/json_rpc_endpoint.py
+++ /dev/null
@@ -1,82 +0,0 @@
-from __future__ import print_function
-
-import json
-import re
-import threading
-
-JSON_RPC_REQ_FORMAT = "Content-Length: {json_string_len}\r\n\r\n{json_string}"
-JSON_RPC_RES_REGEX = "Content-Length: ([0-9]*)\r\n"
-# TODO: add content-type
-
-
-class MyEncoder(json.JSONEncoder):
-    """
-    Encodes an object in JSON
-    """
-
-    def default(self, o):
-        return o.__dict__
-
-
-class JsonRpcEndpoint(object):
-    """
-    Thread safe JSON RPC endpoint implementation. Responsible to recieve and send JSON RPC messages, as described in the
-    protocol. More information can be found: https://www.jsonrpc.org/
-    """
-
-    def __init__(self, stdin, stdout):
-        self.stdin = stdin
-        self.stdout = stdout
-        self.read_lock = threading.Lock()
-        self.write_lock = threading.Lock()
-
-    @staticmethod
-    def __add_header(json_string):
-        """
-        Adds a header for the given json string
-
-        :param str json_string: The string
-        :return: the string with the header
-        """
-        return JSON_RPC_REQ_FORMAT.format(
-            json_string_len=len(json_string), json_string=json_string
-        )
-
-    def send_request(self, message):
-        """
-        Sends the given message.
-
-        :param dict message: The message to send.
-        """
-        json_string = json.dumps(message, cls=MyEncoder)
-        # print("sending:", json_string)
-        jsonrpc_req = self.__add_header(json_string)
-        with self.write_lock:
-            self.stdin.write(jsonrpc_req.encode())
-            self.stdin.flush()
-
-    def recv_response(self):
-        """
-        Recives a message.
-
-         :return: a message
-        """
-        with self.read_lock:
-            line = self.stdout.readline()
-            if not line:
-                return None
-            # print(line)
-            line = line.decode()
-            # TODO: handle content type as well.
-            match = re.match(JSON_RPC_RES_REGEX, line)
-            if match is None or not match.groups():
-                raise RuntimeError("Bad header: " + line)
-            size = int(match.groups()[0])
-            line = self.stdout.readline()
-            if not line:
-                return None
-            line = line.decode()
-            # if line != "\r\n":
-            #     raise RuntimeError("Bad header: missing newline")
-            jsonrpc_res = self.stdout.read(size + 2)
-            return json.loads(jsonrpc_res)
diff --git a/continuedev/src/continuedev/libs/lspclient/lsp_client.py b/continuedev/src/continuedev/libs/lspclient/lsp_client.py
deleted file mode 100644
index fe2db6ad..00000000
--- a/continuedev/src/continuedev/libs/lspclient/lsp_client.py
+++ /dev/null
@@ -1,150 +0,0 @@
-from .lsp_structs import Location, SignatureHelp, SymbolInformation
-
-
-class LspClient(object):
-    def __init__(self, lsp_endpoint):
-        """
-        Constructs a new LspClient instance.
-
-        :param lsp_endpoint: TODO
-        """
-        self.lsp_endpoint = lsp_endpoint
-
-    def initialize(
-        self,
-        processId,
-        rootPath,
-        rootUri,
-        initializationOptions,
-        capabilities,
-        trace,
-        workspaceFolders,
-    ):
-        """
-        The initialize request is sent as the first request from the client to the server. If the server receives a request or notification
-        before the initialize request it should act as follows:
-
-        1. For a request the response should be an error with code: -32002. The message can be picked by the server.
-        2. Notifications should be dropped, except for the exit notification. This will allow the exit of a server without an initialize request.
-
-        Until the server has responded to the initialize request with an InitializeResult, the client must not send any additional requests or
-        notifications to the server. In addition the server is not allowed to send any requests or notifications to the client until it has responded
-        with an InitializeResult, with the exception that during the initialize request the server is allowed to send the notifications window/showMessage,
-        window/logMessage and telemetry/event as well as the window/showMessageRequest request to the client.
-
-        The initialize request may only be sent once.
-
-        :param int processId: The process Id of the parent process that started the server. Is null if the process has not been started by another process.
-                                If the parent process is not alive then the server should exit (see exit notification) its process.
-        :param str rootPath: The rootPath of the workspace. Is null if no folder is open. Deprecated in favour of rootUri.
-        :param DocumentUri rootUri: The rootUri of the workspace. Is null if no folder is open. If both `rootPath` and `rootUri` are set
-                                    `rootUri` wins.
-        :param any initializationOptions: User provided initialization options.
-        :param ClientCapabilities capabilities: The capabilities provided by the client (editor or tool).
-        :param Trace trace: The initial trace setting. If omitted trace is disabled ('off').
-        :param list workspaceFolders: The workspace folders configured in the client when the server starts. This property is only available if the client supports workspace folders.
-                                        It can be `null` if the client supports workspace folders but none are configured.
-        """
-        self.lsp_endpoint.start()
-        return self.lsp_endpoint.call_method(
-            "initialize",
-            processId=processId,
-            rootPath=rootPath,
-            rootUri=rootUri,
-            initializationOptions=initializationOptions,
-            capabilities=capabilities,
-            trace=trace,
-            workspaceFolders=workspaceFolders,
-        )
-
-    def initialized(self):
-        """
-        The initialized notification is sent from the client to the server after the client received the result of the initialize request
-        but before the client is sending any other request or notification to the server. The server can use the initialized notification
-        for example to dynamically register capabilities. The initialized notification may only be sent once.
-        """
-        self.lsp_endpoint.send_notification("initialized")
-
-    def shutdown(self):
-        """
-        The initialized notification is sent from the client to the server after the client received the result of the initialize request
-        but before the client is sending any other request or notification to the server. The server can use the initialized notification
-        for example to dynamically register capabilities. The initialized notification may only be sent once.
-        """
-        self.lsp_endpoint.stop()
-        return self.lsp_endpoint.call_method("shutdown")
-
-    def exit(self):
-        """
-        The initialized notification is sent from the client to the server after the client received the result of the initialize request
-        but before the client is sending any other request or notification to the server. The server can use the initialized notification
-        for example to dynamically register capabilities. The initialized notification may only be sent once.
-        """
-        self.lsp_endpoint.send_notification("exit")
-
-    def didOpen(self, textDocument):
-        """
-        The document open notification is sent from the client to the server to signal newly opened text documents. The document's truth is
-        now managed by the client and the server must not try to read the document's truth using the document's uri. Open in this sense
-        means it is managed by the client. It doesn't necessarily mean that its content is presented in an editor. An open notification must
-        not be sent more than once without a corresponding close notification send before. This means open and close notification must be
-        balanced and the max open count for a particular textDocument is one. Note that a server's ability to fulfill requests is independent
-        of whether a text document is open or closed.
-
-        The DidOpenTextDocumentParams contain the language id the document is associated with. If the language Id of a document changes, the
-        client needs to send a textDocument/didClose to the server followed by a textDocument/didOpen with the new language id if the server
-        handles the new language id as well.
-
-        :param TextDocumentItem textDocument: The initial trace setting. If omitted trace is disabled ('off').
-        """
-        return self.lsp_endpoint.send_notification(
-            "textDocument/didOpen", textDocument=textDocument
-        )
-
-    def documentSymbol(self, textDocument):
-        """
-        The document symbol request is sent from the client to the server to return a flat list of all symbols found in a given text document.
-        Neither the symbol's location range nor the symbol's container name should be used to infer a hierarchy.
-
-        :param TextDocumentItem textDocument: The text document.
-        """
-        result_dict = self.lsp_endpoint.call_method(
-            "textDocument/documentSymbol", textDocument=textDocument
-        )
-        return [SymbolInformation(**sym) for sym in result_dict]
-
-    def definition(self, textDocument, position):
-        """
-        The goto definition request is sent from the client to the server to resolve the definition location of a symbol at a given text document position.
-
-        :param TextDocumentItem textDocument: The text document.
-        :param Position position: The position inside the text document..
-        """
-        result_dict = self.lsp_endpoint.call_method(
-            "textDocument/definition", textDocument=textDocument, position=position
-        )
-        return [Location(**l) for l in result_dict]
-
-    def typeDefinition(self, textDocument, position):
-        """
-        The goto type definition request is sent from the client to the server to resolve the type definition location of a symbol at a given text document position.
-
-        :param TextDocumentItem textDocument: The text document.
-        :param Position position: The position inside the text document..
-        """
-        result_dict = self.lsp_endpoint.call_method(
-            "textDocument/definition", textDocument=textDocument, position=position
-        )
-        return [Location(**l) for l in result_dict]
-
-    def signatureHelp(self, textDocument, position):
-        """
-        The signature help request is sent from the client to the server to request signature information at a given cursor position.
-
-        :param TextDocumentItem textDocument: The text document.
-        :param Position position: The position inside the text document..
-        """
-        result_dict = self.lsp_endpoint.call_method(
-            "textDocument/signatureHelp", textDocument=textDocument, position=position
-        )
-        return SignatureHelp(**result_dict)
diff --git a/continuedev/src/continuedev/libs/lspclient/lsp_endpoint.py b/continuedev/src/continuedev/libs/lspclient/lsp_endpoint.py
deleted file mode 100644
index 9b37a06d..00000000
--- a/continuedev/src/continuedev/libs/lspclient/lsp_endpoint.py
+++ /dev/null
@@ -1,73 +0,0 @@
-from __future__ import print_function
-
-import threading
-import time
-
-
-class LspEndpoint(threading.Thread):
-    def __init__(self, json_rpc_endpoint, default_callback=print, callbacks={}):
-        threading.Thread.__init__(self)
-        self.json_rpc_endpoint = json_rpc_endpoint
-        self.callbacks = callbacks
-        self.default_callback = default_callback
-        self.event_dict = {}
-        self.response_dict = {}
-        self.next_id = 0
-        # self.daemon = True
-        self.shutdown_flag = False
-
-    def handle_result(self, jsonrpc_res):
-        self.response_dict[jsonrpc_res["id"]] = jsonrpc_res
-        cond = self.event_dict[jsonrpc_res["id"]]
-        cond.acquire()
-        cond.notify()
-        cond.release()
-
-    def stop(self):
-        self.shutdown_flag = True
-
-    def run(self):
-        while not self.shutdown_flag:
-            time.sleep(0.1)
-            jsonrpc_message = self.json_rpc_endpoint.recv_response()
-
-            if jsonrpc_message is None:
-                print("server quit")
-                break
-
-            # print("recieved message:", jsonrpc_message)
-            if "result" in jsonrpc_message or "error" in jsonrpc_message:
-                self.handle_result(jsonrpc_message)
-            elif "method" in jsonrpc_message:
-                if jsonrpc_message["method"] in self.callbacks:
-                    self.callbacks[jsonrpc_message["method"]](jsonrpc_message)
-                else:
-                    self.default_callback(jsonrpc_message)
-            else:
-                print("unknown jsonrpc message")
-            # print(jsonrpc_message)
-
-    def send_message(self, method_name, params, id=None):
-        message_dict = {}
-        message_dict["jsonrpc"] = "2.0"
-        if id is not None:
-            message_dict["id"] = id
-        message_dict["method"] = method_name
-        message_dict["params"] = params
-        self.json_rpc_endpoint.send_request(message_dict)
-
-    def call_method(self, method_name, **kwargs):
-        current_id = self.next_id
-        self.next_id += 1
-        cond = threading.Condition()
-        self.event_dict[current_id] = cond
-        cond.acquire()
-        self.send_message(method_name, kwargs, current_id)
-        cond.wait()
-        cond.release()
-        # TODO: check if error, and throw an exception
-        response = self.response_dict[current_id]
-        return response["result"]
-
-    def send_notification(self, method_name, **kwargs):
-        self.send_message(method_name, kwargs)
diff --git a/continuedev/src/continuedev/libs/lspclient/lsp_structs.py b/continuedev/src/continuedev/libs/lspclient/lsp_structs.py
deleted file mode 100644
index 2f0940d4..00000000
--- a/continuedev/src/continuedev/libs/lspclient/lsp_structs.py
+++ /dev/null
@@ -1,316 +0,0 @@
-def to_type(o, new_type):
-    '''
-    Helper funciton that receives an object or a dict and convert it to a new given type.
-
-    :param object|dict o: The object to convert
-    :param Type new_type: The type to convert to.
-    '''
-    if new_type == type(o):
-        return o
-    else:
-        return new_type(**o)
-
-
-class Position(object):
-    def __init__(self, line, character):
-        """
-        Constructs a new Position instance.
-
-        :param int line: Line position in a document (zero-based).
-        :param int character: Character offset on a line in a document (zero-based).
-        """
-        self.line = line
-        self.character = character
-
-
-class Range(object):
-    def __init__(self, start, end):
-        """
-        Constructs a new Range instance.
-
-        :param Position start: The range's start position.
-        :param Position end: The range's end position.
-        """
-        self.start = to_type(start, Position)
-        self.end = to_type(end, Position)
-
-
-class Location(object):
-    """
-    Represents a location inside a resource, such as a line inside a text file.
-    """
-    def __init__(self, uri, range):
-        """
-        Constructs a new Range instance.
-
-        :param str uri: Resource file.
-        :param Range range: The range inside the file
-        """
-        self.uri = uri
-        self.range = to_type(range, Range)
-
- 
-class Diagnostic(object):
-     def __init__(self, range, severity, code, source, message, relatedInformation):
-        """
-        Constructs a new Diagnostic instance.
-        :param Range range: The range at which the message applies.Resource file.
-        :param int severity: The diagnostic's severity. Can be omitted. If omitted it is up to the
-                                client to interpret diagnostics as error, warning, info or hint.
-        :param str code: The diagnostic's code, which might appear in the user interface.
-        :param str source: A human-readable string describing the source of this
-                            diagnostic, e.g. 'typescript' or 'super lint'.
-        :param str message: The diagnostic's message.
-        :param list relatedInformation: An array of related diagnostic information, e.g. when symbol-names within   
-                                        a scope collide all definitions can be marked via this property.
-        """
-        self.range = range
-        self.severity = severity
-        self.code = code
-        self.source = source
-        self.message = message
-        self.relatedInformation = relatedInformation
-
-
-class DiagnosticSeverity(object):
-    Error = 1
-    Warning = 2 # TODO: warning is known in python
-    Information = 3
-    Hint = 4
-
-
-class DiagnosticRelatedInformation(object):
-    def __init__(self, location, message):
-        """
-        Constructs a new Diagnostic instance.
-        :param Location location: The location of this related diagnostic information.
-        :param str message: The message of this related diagnostic information.
-        """
-        self.location = location
-        self.message = message
-
- 
-class Command(object):
-     def __init__(self, title, command, arguments):
-        """
-        Constructs a new Diagnostic instance.
-        :param str title: Title of the command, like `save`.
-        :param str command: The identifier of the actual command handler.
-        :param list argusments: Arguments that the command handler should be invoked with.
-        """
-        self.title = title
-        self.command = command
-        self.arguments = arguments
-
-
-class TextDocumentItem(object):
-    """
-    An item to transfer a text document from the client to the server.
-    """
-    def __init__(self, uri, languageId, version, text):
-        """
-        Constructs a new Diagnostic instance.
-        
-        :param DocumentUri uri: Title of the command, like `save`.
-        :param str languageId: The identifier of the actual command handler.
-        :param int version: Arguments that the command handler should be invoked with.
-        :param str text: Arguments that the command handler should be invoked with.
-        """
-        self.uri = uri
-        self.languageId = languageId
-        self.version = version
-        self.text = text
-
-
-class TextDocumentIdentifier(object):
-    """
-    Text documents are identified using a URI. On the protocol level, URIs are passed as strings. 
-    """
-    def __init__(self, uri):
-        """
-        Constructs a new TextDocumentIdentifier instance.
-
-        :param DocumentUri uri: The text document's URI.       
-        """
-        self.uri = uri
-
-class TextDocumentPositionParams(object):
-    """
-    A parameter literal used in requests to pass a text document and a position inside that document.
-    """
-    def __init__(self, textDocument, position):
-        """
-        Constructs a new TextDocumentPositionParams instance.
-        
-        :param TextDocumentIdentifier textDocument: The text document.
-        :param Position position: The position inside the text document.
-        """
-        self.textDocument = textDocument
-        self.position = position
-
-
-class LANGUAGE_IDENTIFIER:
-    BAT="bat"
-    BIBTEX="bibtex"
-    CLOJURE="clojure"
-    COFFESCRIPT="coffeescript"
-    C="c"
-    CPP="cpp"
-    CSHARP="csharp"
-    CSS="css"
-    DIFF="diff"
-    DOCKERFILE="dockerfile"
-    FSHARP="fsharp"
-    GIT_COMMIT="git-commit"
-    GIT_REBASE="git-rebase"
-    GO="go"
-    GROOVY="groovy"
-    HANDLEBARS="handlebars"
-    HTML="html"
-    INI="ini"
-    JAVA="java"
-    JAVASCRIPT="javascript"
-    JSON="json"
-    LATEX="latex"
-    LESS="less"
-    LUA="lua"
-    MAKEFILE="makefile"
-    MARKDOWN="markdown"
-    OBJECTIVE_C="objective-c"
-    OBJECTIVE_CPP="objective-cpp"
-    Perl="perl"
-    PHP="php"
-    POWERSHELL="powershell"
-    PUG="jade"
-    PYTHON="python"
-    R="r"
-    RAZOR="razor"
-    RUBY="ruby"
-    RUST="rust"
-    SASS="sass"
-    SCSS="scss"
-    ShaderLab="shaderlab"
-    SHELL_SCRIPT="shellscript"
-    SQL="sql"
-    SWIFT="swift"
-    TYPE_SCRIPT="typescript"
-    TEX="tex"
-    VB="vb"
-    XML="xml"
-    XSL="xsl"
-    YAML="yaml"
-
-
-class SymbolKind(object):
-    File = 1
-    Module = 2
-    Namespace = 3
-    Package = 4
-    Class = 5
-    Method = 6
-    Property = 7
-    Field = 8
-    Constructor = 9
-    Enum = 10
-    Interface = 11
-    Function = 12
-    Variable = 13
-    Constant = 14
-    String = 15
-    Number = 16
-    Boolean = 17
-    Array = 18
-    Object = 19
-    Key = 20
-    Null = 21
-    EnumMember = 22
-    Struct = 23
-    Event = 24
-    Operator = 25
-    TypeParameter = 26
-
-
-class SymbolInformation(object):
-    """
-    Represents information about programming constructs like variables, classes, interfaces etc.
-    """
-    def __init__(self, name, kind, location, containerName, deprecated=False):
-        """
-        Constructs a new SymbolInformation instance.
-
-        :param str name: The name of this symbol.
-        :param int kind: The kind of this symbol.
-        :param bool Location: The location of this symbol. The location's range is used by a tool
-                                to reveal the location in the editor. If the symbol is selected in the
-                                tool the range's start information is used to position the cursor. So
-                                the range usually spans more then the actual symbol's name and does
-                                normally include things like visibility modifiers.
-
-                                The range doesn't have to denote a node range in the sense of a abstract
-                                syntax tree. It can therefore not be used to re-construct a hierarchy of
-                                the symbols.
-        :param str containerName: The name of the symbol containing this symbol. This information is for
-                                    user interface purposes (e.g. to render a qualifier in the user interface
-                                    if necessary). It can't be used to re-infer a hierarchy for the document
-                                    symbols.
-        :param bool deprecated: Indicates if this symbol is deprecated.
-        """
-        self.name = name
-        self.kind = kind
-        self.deprecated = deprecated
-        self.location = to_type(location, Location)
-        self.containerName = containerName
-
-
-class ParameterInformation(object):
-    """
-    Represents a parameter of a callable-signature. A parameter can
-    have a label and a doc-comment.
-    """
-    def __init__(self, label, documentation=""):
-        """
-        Constructs a new ParameterInformation instance.
-
-        :param str label: The label of this parameter. Will be shown in the UI.
-        :param str documentation: The human-readable doc-comment of this parameter. Will be shown in the UI but can be omitted.
-        """
-        self.label = label
-        self.documentation = documentation
-
-
-class SignatureInformation(object):
-    """
-    Represents the signature of something callable. A signature
-    can have a label, like a function-name, a doc-comment, and
-    a set of parameters.
-    """
-    def __init__(self, label, documentation="", parameters=[]):
-        """
-        Constructs a new SignatureInformation instance.
-
-        :param str label: The label of this signature. Will be shown in the UI.
-        :param str documentation: The human-readable doc-comment of this signature. Will be shown in the UI but can be omitted.
-        :param ParameterInformation[] parameters: The parameters of this signature.
-        """
-        self.label = label
-        self.documentation = documentation
-        self.parameters = [to_type(parameter, ParameterInformation) for parameter in parameters]
-
-
-class SignatureHelp(object):
-    """
-    Signature help represents the signature of something
-    callable. There can be multiple signature but only one
-    active and only one active parameter.
-    """
-    def __init__(self, signatures, activeSignature=0, activeParameter=0):
-        """
-        Constructs a new SignatureHelp instance.
-
-        :param SignatureInformation[] signatures: One or more signatures.
-        :param int activeSignature:
-        :param int activeParameter:
-        """
-        self.signatures = [to_type(signature, SignatureInformation) for signature in signatures]
-        self.activeSignature = activeSignature
-        self.activeParameter = activeParameter
\ No newline at end of file
diff --git a/continuedev/src/continuedev/plugins/steps/on_traceback.py b/continuedev/src/continuedev/plugins/steps/on_traceback.py
index 078309d0..3a96a8c7 100644
--- a/continuedev/src/continuedev/plugins/steps/on_traceback.py
+++ b/continuedev/src/continuedev/plugins/steps/on_traceback.py
@@ -175,7 +175,7 @@ async def get_function_body(frame: TracebackFrame, sdk: ContinueSDK) -> Optional
     if sdk.lsp is None:
         return None
 
-    document_symbols = sdk.lsp.get_symbols(frame.filepath)
+    document_symbols = await sdk.lsp.document_symbol(frame.filepath)
     for symbol in document_symbols:
         if symbol.name == frame.function:
             r = symbol.location.range