Merge main into feature/q-lsp-chat

plugins/amazonq/chat/jetbrains-community/src/software/aws/toolkits/jetbrains/services/amazonq/QRefreshPanelAction.kt

@@ -11,7 +11,6 @@ import com.intellij.openapi.project.DumbAwareAction
 import com.intellij.util.messages.Topic
 import software.aws.toolkits.jetbrains.services.amazonq.toolwindow.AmazonQToolWindow
 import software.aws.toolkits.resources.AmazonQBundle
-import software.aws.toolkits.resources.message
 import java.util.EventListener
 
 class QRefreshPanelAction : DumbAwareAction(AmazonQBundle.message("amazonq.refresh.panel"), null, AllIcons.Actions.Refresh) {

plugins/amazonq/chat/jetbrains-community/src/software/aws/toolkits/jetbrains/services/amazonq/toolwindow/AmazonQToolWindow.kt

@@ -20,14 +20,13 @@
     private val project: Project,
     private val scope: CoroutineScope,
 ) : Disposable {
     private var chatPanel = AmazonQPanel(project, scope)
 
     val component
         get() = chatPanel.component
-
     fun disposeAndRecreate() {
         Disposer.dispose(chatPanel)
         chatPanel = AmazonQPanel(project, scope)
     }
 
     companion object {
@@ -44,13 +43,13 @@
 
             // Send the interaction message
             val window = getInstance(project)
             window.chatPanel.sendMessage(OnboardingPageInteraction(OnboardingPageInteractionType.CwcButtonClick), "cwc")
         }
 
         fun openScanTab(project: Project) {
             showChatWindow(project)
             val window = getInstance(project)
             window.chatPanel.sendMessageAppToUi(runCodeScanMessage, tabType = "codescan")
         }
     }
 

plugins/amazonq/chat/jetbrains-community/src/software/aws/toolkits/jetbrains/services/amazonq/toolwindow/AmazonQToolWindowFactory.kt

@@ -66,7 +66,7 @@
                     ToolkitConnectionManager.getInstance(project).activeConnectionForFeature(QConnection.getInstance())?.let { qConn ->
                         openMeetQPage(project)
                     }
-                    prepareChatContent(project, qPanel)
+                    preparePanelContent(project, qPanel)
                 }
             }
         )
@@ -75,7 +75,7 @@
             RefreshQChatPanelButtonPressedListener.TOPIC,
             object : RefreshQChatPanelButtonPressedListener {
                 override fun onRefresh() {
-                    prepareChatContent(project, qPanel)
+                    preparePanelContent(project, qPanel)
                 }
             }
         )
@@ -85,8 +85,7 @@
             object : BearerTokenProviderListener {
                 override fun onChange(providerId: String, newScopes: List<String>?) {
                     if (ToolkitConnectionManager.getInstance(project).connectionStateForFeature(QConnection.getInstance()) == BearerTokenAuthState.AUTHORIZED) {
-                        AmazonQToolWindow.getInstance(project).disposeAndRecreate()
-                        prepareChatContent(project, qPanel)
+                        preparePanelContent(project, qPanel)
                     }
                 }
             }
@@ -98,13 +97,12 @@
                 // note we name myProject intentionally ow it will shadow the "project" provided by the IDE
                 override fun onProfileSelected(myProject: Project, profile: QRegionProfile?) {
                     if (project.isDisposed) return
-                    AmazonQToolWindow.getInstance(project).disposeAndRecreate()
-                    prepareChatContent(project, qPanel)
+                    preparePanelContent(project, qPanel)
                 }
             }
         )
 
-        prepareChatContent(project, qPanel)
+        preparePanelContent(project, qPanel)
 
         val content = contentManager.factory.createContent(mainPanel, null, false).also {
             it.isCloseable = true
@@ -114,7 +112,7 @@
         contentManager.addContent(content)
     }
 
-    private fun prepareChatContent(
+    private fun preparePanelContent(
         project: Project,
         qPanel: Wrapper,
     ) {

plugins/amazonq/chat/jetbrains-community/src/software/aws/toolkits/jetbrains/services/cwc/commands/ActionRegistrar.kt

@@ -11,7 +11,9 @@
 import kotlinx.coroutines.runBlocking
 import software.aws.toolkits.jetbrains.services.amazonq.lsp.flareChat.AsyncChatUiListener
 import software.aws.toolkits.jetbrains.services.amazonq.lsp.flareChat.FlareUiMessage
+import software.aws.toolkits.jetbrains.services.amazonq.lsp.model.aws.chat.GENERIC_COMMAND
 import software.aws.toolkits.jetbrains.services.amazonq.lsp.model.aws.chat.GenericCommandParams
+import software.aws.toolkits.jetbrains.services.amazonq.lsp.model.aws.chat.SEND_TO_PROMPT
 import software.aws.toolkits.jetbrains.services.amazonq.lsp.model.aws.chat.SendToPromptParams
 import software.aws.toolkits.jetbrains.services.amazonq.lsp.model.aws.chat.TriggerType
 import software.aws.toolkits.jetbrains.services.amazonq.messages.AmazonQMessage
@@ -27,32 +29,28 @@
 
     fun reportMessageClick(command: EditorContextCommand, project: Project) {
         if (command == EditorContextCommand.GenerateUnitTests) {
             AsyncChatUiListener.notifyPartialMessageUpdate(Gson().toJson(TestCommandMessage()))
         } else {
             // new agentic chat route
             ApplicationManager.getApplication().executeOnPooledThread {
                 runBlocking {
                     val contextExtractor = ActiveFileContextExtractor.create(fqnWebviewAdapter = null, project = project)
                     val fileContext = contextExtractor.extractContextForTrigger(ExtractionTriggerType.ContextMenu)
                     val codeSelection = "\n```\n${fileContext.focusAreaContext?.codeSelection?.trimIndent()?.trim()}\n```\n"
                     var uiMessage: FlareUiMessage? = null
-                    if (command.verb != "sendToPrompt") {
+                    if (command.verb != SEND_TO_PROMPT) {
                         val params = GenericCommandParams(selection = codeSelection, triggerType = TriggerType.CONTEXT_MENU, genericCommand = command.name)
-                        uiMessage = FlareUiMessage(command = "genericCommand", params = params)
+                        uiMessage = FlareUiMessage(command = GENERIC_COMMAND, params = params)
                     } else {
                         val params = SendToPromptParams(selection = codeSelection, triggerType = TriggerType.CONTEXT_MENU)
-                        uiMessage = FlareUiMessage(command = "sendToPrompt", params = params)
+                        uiMessage = FlareUiMessage(command = SEND_TO_PROMPT, params = params)
                     }
                     AsyncChatUiListener.notifyPartialMessageUpdate(uiMessage)
                 }
             }
         }
     }
 
-    fun reportMessageClick(command: EditorContextCommand, issue: MutableMap<String, String>, project: Project) {
-        _messages.tryEmit(CodeScanIssueActionMessage(command, issue, project))
-    }
-
     // provide singleton access
     companion object {
         val instance = ActionRegistrar()

plugins/amazonq/chat/jetbrains-community/src/software/aws/toolkits/jetbrains/services/cwc/commands/codescan/actions/ExplainCodeIssueAction.kt

@@ -3,6 +3,55 @@
 
 package software.aws.toolkits.jetbrains.services.cwc.commands.codescan.actions
 
-import software.aws.toolkits.jetbrains.services.cwc.commands.EditorContextCommand
+import com.intellij.openapi.actionSystem.ActionManager
+import com.intellij.openapi.actionSystem.AnAction
+import com.intellij.openapi.actionSystem.AnActionEvent
+import com.intellij.openapi.actionSystem.DataKey
+import com.intellij.openapi.application.ApplicationManager
+import com.intellij.openapi.project.DumbAware
+import kotlinx.coroutines.runBlocking
+import software.aws.toolkits.jetbrains.services.amazonq.lsp.flareChat.AsyncChatUiListener
+import software.aws.toolkits.jetbrains.services.amazonq.lsp.flareChat.FlareUiMessage
+import software.aws.toolkits.jetbrains.services.amazonq.lsp.model.aws.chat.ChatPrompt
+import software.aws.toolkits.jetbrains.services.amazonq.lsp.model.aws.chat.SEND_TO_PROMPT
+import software.aws.toolkits.jetbrains.services.amazonq.lsp.model.aws.chat.SendToPromptParams
+import software.aws.toolkits.jetbrains.services.amazonq.lsp.model.aws.chat.TriggerType
 
-class ExplainCodeIssueAction : CodeScanQActions(EditorContextCommand.ExplainCodeScanIssue)
+class ExplainCodeIssueAction : AnAction(), DumbAware {
+    override fun actionPerformed(e: AnActionEvent) {
+        val issueDataKey = DataKey.create<MutableMap<String, String>>("amazonq.codescan.explainissue")
+        val issueContext = e.getData(issueDataKey) ?: return
+
+        ActionManager.getInstance().getAction("q.openchat").actionPerformed(e)
+
+        ApplicationManager.getApplication().executeOnPooledThread {
+            runBlocking {
+                // https://github.com/aws/aws-toolkit-vscode/blob/master/packages/amazonq/src/lsp/chat/commands.ts#L30
+                val codeSelection = "\n```\n${issueContext["code"]?.trimIndent()?.trim()}\n```\n"
+
+                val prompt = "Explain the issue \n\n " +
+                    "Issue:    \"${issueContext["title"]}\" \n" +
+                    "Code:    $codeSelection"
+
+                val modelPrompt = "Explain the issue ${issueContext["title"]} \n\n " +
+                    "Issue:    \"${issueContext["title"]}\" \n" +
+                    "Description:    ${issueContext["description"]} \n" +
+                    "Code:    $codeSelection and generate the code demonstrating the fix"
+
+                val params = SendToPromptParams(
+                    selection = codeSelection,
+                    triggerType = TriggerType.CONTEXT_MENU,
+                    prompt = ChatPrompt(
+                        prompt = prompt,
+                        escapedPrompt = modelPrompt,
+                        command = null
+                    ),
+                    autoSubmit = true
+                )
+
+                val uiMessage = FlareUiMessage(SEND_TO_PROMPT, params)
+                AsyncChatUiListener.notifyPartialMessageUpdate(uiMessage)
+            }
+        }
+    }
+}

plugins/amazonq/codewhisperer/jetbrains-community/src/software/aws/toolkits/jetbrains/services/codewhisperer/editor/CodeWhispererEditorUtil.kt

@@ -32,7 +32,8 @@
         val fileName = getFileName(psiFile)
         val programmingLanguage = psiFile.programmingLanguage()
         val fileRelativePath = getRelativePathToContentRoot(editor)
-        return FileContextInfo(caretContext, fileName, programmingLanguage, fileRelativePath)
+        val fileUri = getFileUri(psiFile)
+        return FileContextInfo(caretContext, fileName, programmingLanguage, fileRelativePath, fileUri)
     }
 
     fun extractCaretContext(editor: Editor): CaretContext {
@@ -73,6 +74,11 @@
     private fun getFileName(psiFile: PsiFile): String =
         psiFile.name.substring(0, psiFile.name.length.coerceAtMost(CodeWhispererConstants.FILENAME_CHARS_LIMIT))
 
+    private fun getFileUri(psiFile: PsiFile): String? =
+        psiFile.virtualFile?.takeIf { it.isValid }?.let { vFile ->
+            vFile.url.substring(0, vFile.url.length.coerceAtMost(CodeWhispererConstants.FILENAME_CHARS_LIMIT))
+        }
+
     fun getRelativePathToContentRoot(editor: Editor): String? =
         editor.project?.let { project ->
             FileDocumentManager.getInstance().getFile(editor.document)?.let { vFile ->

plugins/amazonq/codewhisperer/jetbrains-community/src/software/aws/toolkits/jetbrains/services/codewhisperer/model/CodeWhispererModel.kt

@@ -47,17 +47,18 @@
     val filename: String,
     val programmingLanguage: CodeWhispererProgrammingLanguage,
     val fileRelativePath: String?,
+    val fileUri: String?,
 )
 
 data class RecommendationContext(
     val details: List<DetailContext>,
     val userInput: String,
     val position: VisualPosition,
 )
 
 data class RecommendationContextNew(
     val details: MutableList<DetailContext>,
     val userInput: String,
     val position: VisualPosition,
     val jobId: Int,
     var typeahead: String = "",
@@ -65,14 +66,14 @@
 
 data class PreviewContext(
     val jobId: Int,
     val detail: DetailContext,
     val userInput: String,
     val typeahead: String,
 )
 
 data class DetailContext(
     val itemId: String,
     val completion: InlineCompletionItem,
     val isDiscarded: Boolean,
     val completionType: CodewhispererCompletionType,
     var hasSeen: Boolean = false,
@@ -115,7 +116,7 @@
 
     @RequiresEdt
     override fun dispose() {
         CodeWhispererTelemetryServiceNew.getInstance().sendUserTriggerDecisionEvent(this.project, this.latencyContext)
         setIntelliSensePopupAlpha(editor, 0f)
         CodeWhispererInvocationStatusNew.getInstance().setDisplaySessionActive(false)
 
@@ -172,14 +173,14 @@
 data class WorkerContext(
     val requestContext: RequestContext,
     val responseContext: ResponseContext,
     val completions: InlineCompletionListWithReferences,
     val popup: JBPopup,
 )
 
 data class WorkerContextNew(
     val requestContext: RequestContextNew,
     val responseContext: ResponseContext,
     val completions: InlineCompletionListWithReferences,
 )
 
 data class CodeScanTelemetryEvent(

plugins/amazonq/codewhisperer/jetbrains-community/tst/software/aws/toolkits/jetbrains/services/codewhisperer/CodeWhispererServiceTest.kt

@@ -74,7 +74,8 @@ class CodeWhispererServiceTest : CodeWhispererTestBase() {
                 CaretContext(leftFileContext = "", rightFileContext = "public class Main {}", leftContextOnCurrentLine = ""),
                 "main.java",
                 CodeWhispererJava.INSTANCE,
-                "main.java"
+                "main.java",
+                file.virtualFile.url
             )
         )
     }

plugins/amazonq/codewhisperer/jetbrains-community/tst/software/aws/toolkits/jetbrains/services/codewhisperer/CodeWhispererTestUtil.kt

@@ -127,7 +127,7 @@ fun aFileContextInfo(language: CodeWhispererProgrammingLanguage? = null): FileCo
         CodeWhispererJava.INSTANCE
     ).random()
 
-    return FileContextInfo(caretContextInfo, fileName, programmingLanguage, fileRelativePath)
+    return FileContextInfo(caretContextInfo, fileName, programmingLanguage, fileRelativePath, null)
 }
 
 fun aTriggerType(): CodewhispererTriggerType =

plugins/amazonq/mynah-ui/src/mynah-ui/ui/texts/disclaimer.ts

@@ -8,7 +8,7 @@ import { ChatItem, MynahIcons } from '@aws/mynah-ui-chat'
 export const disclaimerAcknowledgeButtonId = 'amazonq-disclaimer-acknowledge-button-id'
 export const disclaimerCard: Partial<ChatItem> = {
     messageId: 'amazonq-disclaimer-card',
-    body: 'Amazon Q Developer uses generative AI. You may need to verify responses. See the [AWS Responsible AI Policy](https://aws.amazon.com/machine-learning/responsible-ai/policy/). Amazon Q Developer processes data across all US Regions. See [here](https://docs.aws.amazon.com/amazonq/latest/qdeveloper-ug/cross-region-inference.html) for more info. Amazon Q may retain chats to provide and maintain the service.',
+    body: 'Amazon Q Developer uses generative AI. You may need to verify responses. See the [AWS Responsible AI Policy](https://aws.amazon.com/machine-learning/responsible-ai/policy/). Amazon Q may retain chats to provide and maintain the service. For information on the AWS Regions where Amazon Q may perform inference, see [the documentation](https://docs.aws.amazon.com/amazonq/latest/qdeveloper-ug/cross-region-processing.html#cross-region-inference).',
     buttons: [
         {
             text: 'Acknowledge',

plugins/amazonq/shared/jetbrains-community/src/software/aws/toolkits/jetbrains/services/amazonq/lsp/AmazonQLspService.kt

@@ -24,12 +24,16 @@
 import com.intellij.util.net.JdkProxyProvider
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Deferred
+import kotlinx.coroutines.Job
 import kotlinx.coroutines.async
 import kotlinx.coroutines.channels.BufferOverflow
+import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.asSharedFlow
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.future.asCompletableFuture
+import kotlinx.coroutines.isActive
+import kotlinx.coroutines.launch
 import kotlinx.coroutines.runBlocking
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
@@ -52,6 +56,7 @@
 import org.eclipse.lsp4j.jsonrpc.messages.ResponseMessage
 import org.eclipse.lsp4j.launch.LSPLauncher
 import org.slf4j.event.Level
+import software.aws.toolkits.core.utils.debug
 import software.aws.toolkits.core.utils.getLogger
 import software.aws.toolkits.core.utils.info
 import software.aws.toolkits.core.utils.warn
@@ -119,18 +124,21 @@
 
 @Service(Service.Level.PROJECT)
 class AmazonQLspService(private val project: Project, private val cs: CoroutineScope) : Disposable {
     private val _flowInstance = MutableSharedFlow<AmazonQServerInstance>(replay = 1, onBufferOverflow = BufferOverflow.DROP_OLDEST)
     val instanceFlow = _flowInstance.asSharedFlow().map { it.languageServer }
 
     private var instance: Deferred<AmazonQServerInstance>
     val capabilities
         get() = instance.getCompleted().initializeResult.getCompleted().capabilities
 
     val encryptionManager
         get() = instance.getCompleted().encryptionManager
+    private val heartbeatJob: Job
+    private val restartTimestamps = ArrayDeque<Long>()
+    private val restartMutex = Mutex() // Separate mutex for restart tracking
 
     val rawEndpoint
         get() = instance.getCompleted().rawEndpoint
 
     // dont allow lsp commands if server is restarting
     private val mutex = Mutex(false)
@@ -141,20 +149,20 @@
         var attempts = 0
         while (attempts < 3) {
             try {
                 val result = withTimeout(30.seconds) {
                     val instance = AmazonQServerInstance(project, cs).also {
                         Disposer.register(this@AmazonQLspService, it)
                     }
                     // wait for handshake to complete
                     instance.initializeResult.join()
 
                     instance.also {
                         _flowInstance.emit(it)
                     }
                 }
 
                 // withTimeout can throw
                 return@async result
             } catch (e: Exception) {
                 LOG.warn(e) { "Failed to start LSP server" }
             }
@@ -166,9 +174,50 @@
 
     init {
         instance = start()
+
+        // Initialize heartbeat job
+        heartbeatJob = cs.launch {
+            while (isActive) {
+                delay(5.seconds) // Check every 5 seconds
+                val shouldLoop = checkConnectionStatus()
+                if (!shouldLoop) {
+                    break
+                }
+            }
+        }
+    }
+
+    private suspend fun checkConnectionStatus(): Boolean {
+        try {
+            val currentInstance = mutex.withLock { instance }.await()
+
+            // Check if the launcher's Future (startListening) is done
+            // If it's done, that means the connection has been terminated
+            if (currentInstance.launcherFuture.isDone) {
+                LOG.debug { "LSP server connection terminated, checking restart limits" }
+                val canRestart = checkForRemainingRestartAttempts()
+                if (!canRestart) {
+                    return false
+                }
+                LOG.debug { "Restarting LSP server" }
+                restart()
+            } else {
+                LOG.debug { "LSP server is currently running" }
+            }
+        } catch (e: Exception) {
+            LOG.debug(e) { "Connection status check failed, checking restart limits" }
+            val canRestart = checkForRemainingRestartAttempts()
+            if (!canRestart) {
+                return false
+            }
+            LOG.debug { "Restarting LSP server" }
+            restart()
+        }
+        return true
     }
 
     override fun dispose() {
+        heartbeatJob.cancel()
     }
 
     suspend fun restart() = mutex.withLock {
@@ -195,6 +244,25 @@
         instance = start()
     }
 
+    private suspend fun checkForRemainingRestartAttempts(): Boolean = restartMutex.withLock {
+        val currentTime = System.currentTimeMillis()
+
+        while (restartTimestamps.isNotEmpty() &&
+            currentTime - restartTimestamps.first() > RESTART_WINDOW_MS
+        ) {
+            restartTimestamps.removeFirst()
+        }
+
+        if (restartTimestamps.size < MAX_RESTARTS) {
+            restartTimestamps.addLast(currentTime)
+            return true
+        }
+
+        LOG.info { "Rate limit reached for LSP server restarts. Stop attempting to restart." }
+
+        return false
+    }
+
     suspend fun<T> execute(runnable: suspend AmazonQLspService.(AmazonQLanguageServer) -> T): T {
         val lsp = withTimeout(10.seconds) {
             val holder = mutex.withLock { instance }.await()
@@ -212,6 +280,8 @@
 
     companion object {
         private val LOG = getLogger<AmazonQLspService>()
+        private const val MAX_RESTARTS = 5
+        private const val RESTART_WINDOW_MS = 3 * 60 * 1000
         fun getInstance(project: Project) = project.service<AmazonQLspService>()
 
         @Deprecated("Easy to accidentally freeze EDT")
@@ -230,7 +300,7 @@
 }
 
 private class AmazonQServerInstance(private val project: Project, private val cs: CoroutineScope) : Disposable {
     val encryptionManager = JwtEncryptionManager()
 
     private val launcher: Launcher<AmazonQLanguageServer>
 
@@ -238,10 +308,10 @@
         get() = launcher.remoteProxy
 
     val rawEndpoint: RemoteEndpoint
         get() = launcher.remoteEndpoint
 
     @Suppress("ForbiddenVoid")
-    private val launcherFuture: Future<Void>
+    val launcherFuture: Future<Void>
     private val launcherHandler: KillableProcessHandler
     val initializeResult: Deferred<InitializeResult>
 
@@ -288,18 +358,18 @@
 
     init {
         // will cause slow service init, but maybe fine for now. will not block UI since fetch/extract will be under background progress
         val artifact = runBlocking { service<ArtifactManager>().fetchArtifact(project) }.toAbsolutePath()
 
         // more network calls
         // make assumption that all requests will resolve to the same CA
         // also terrible assumption that default endpoint is reachable
         val qUri = URI(QDefaultServiceConfig.ENDPOINT)
         val rtsTrustChain = TrustChainUtil.getTrustChain(qUri)
         val extraCaCerts = Files.createTempFile("q-extra-ca", ".pem").apply {
             writeText(
                 TrustChainUtil.certsToPem(rtsTrustChain)
             )
         }
 
         val node = if (SystemInfo.isWindows) "node.exe" else "node"
         val cmd = GeneralCommandLine(
@@ -307,49 +377,49 @@
             LspSettings.getInstance().getArtifactPath() ?: artifact.resolve("aws-lsp-codewhisperer.js").toString(),
             "--stdio",
             "--set-credentials-encryption-key",
         ).withEnvironment(
             buildMap {
                 put("NODE_EXTRA_CA_CERTS", extraCaCerts.toAbsolutePath().toString())
 
                 val proxy = JdkProxyProvider.getInstance().proxySelector.select(qUri)
                     // log if only socks proxy available
                     .firstOrNull { it.type() == Proxy.Type.HTTP }
 
                 if (proxy != null) {
                     val address = proxy.address()
                     if (address is java.net.InetSocketAddress) {
                         put(
                             "HTTPS_PROXY",
                             URIBuilder("http://${address.hostName}:${address.port}").apply {
                                 val login = HttpConfigurable.getInstance().proxyLogin
                                 if (login != null) {
                                     setUserInfo(login, HttpConfigurable.getInstance().plainProxyPassword)
                                 }
                             }.build().toASCIIString()
                         )
                     }
                 }
             }
         )
             .withParentEnvironmentType(GeneralCommandLine.ParentEnvironmentType.CONSOLE)
 
         launcherHandler = KillableColoredProcessHandler.Silent(cmd)
         val inputWrapper = LSPProcessListener()
         launcherHandler.addProcessListener(inputWrapper)
         launcherHandler.startNotify()
 
         launcher = object : LSPLauncher.Builder<AmazonQLanguageServer>() {
             override fun getSupportedMethods(): Map<String, JsonRpcMethod> =
                 super.getSupportedMethods() + AmazonQChatServer.supportedMethods()
         }
             .wrapMessages { consumer ->
                 MessageConsumer { message ->
                     if (message is ResponseMessage && message.result is AwsExtendedInitializeResult) {
                         val result = message.result as AwsExtendedInitializeResult
                         AwsServerCapabilitiesProvider.getInstance(project).setAwsServerCapabilities(result.getAwsServerCapabilities())
                     }
                     consumer?.consume(message)
                 }
             }
             .setLocalService(AmazonQLanguageClientImpl(project))
             .setRemoteInterface(AmazonQLanguageServer::class.java)
@@ -359,7 +429,7 @@
 
                 // otherwise Gson treats all numbers as double which causes deser issues
                 it.setObjectToNumberStrategy(ToNumberPolicy.LONG_OR_DOUBLE)
                 it.registerTypeAdapterFactory(AmazonQLspTypeAdapterFactory())
             }.traceMessages(
                 PrintWriter(
                     object : StringWriter() {
@@ -383,7 +453,7 @@
             encryptionManager.writeInitializationPayload(launcherHandler.process.outputStream)
 
             val initializeResult = try {
                 languageServer.initialize(createInitializeParams()).await()
             } catch (e: Exception) {
                 LOG.warn(e) { "LSP initialization failed" }
                 null
@@ -400,7 +470,7 @@
         }
 
         // invokeOnCompletion results in weird lock/timeout error
         initializeResult.asCompletableFuture().handleAsync { lspInitResult, ex ->
             if (ex != null) {
                 return@handleAsync
             }
@@ -408,7 +478,7 @@
             [email protected] {
                 DefaultAuthCredentialsService(project, encryptionManager, this)
                 TextDocumentServiceHandler(project, this)
                 WorkspaceServiceHandler(project, lspInitResult, this)
                 DefaultModuleDependenciesService(project, this)
             }
         }