diff --git a/plugins/amazonq/chat/jetbrains-community/src/software/aws/toolkits/jetbrains/services/amazonq/toolwindow/AmazonQPanel.kt b/plugins/amazonq/chat/jetbrains-community/src/software/aws/toolkits/jetbrains/services/amazonq/toolwindow/AmazonQPanel.kt
index afd61f70a9d..41487d0a658 100644
--- a/plugins/amazonq/chat/jetbrains-community/src/software/aws/toolkits/jetbrains/services/amazonq/toolwindow/AmazonQPanel.kt
+++ b/plugins/amazonq/chat/jetbrains-community/src/software/aws/toolkits/jetbrains/services/amazonq/toolwindow/AmazonQPanel.kt
@@ -7,6 +7,7 @@ import com.intellij.idea.AppMode
 import com.intellij.openapi.Disposable
 import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.application.runInEdt
+import com.intellij.openapi.components.service
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.util.Disposer
 import com.intellij.ui.components.JBLoadingPanel
@@ -19,11 +20,12 @@ import com.intellij.ui.dsl.builder.panel
 import com.intellij.ui.jcef.JBCefApp
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
 import software.aws.toolkits.jetbrains.isDeveloperMode
 import software.aws.toolkits.jetbrains.services.amazonq.apps.AmazonQAppInitContext
 import software.aws.toolkits.jetbrains.services.amazonq.apps.AppConnection
 import software.aws.toolkits.jetbrains.services.amazonq.commands.MessageTypeRegistry
-import software.aws.toolkits.jetbrains.services.amazonq.lsp.artifacts.ArtifactHelper
+import software.aws.toolkits.jetbrains.services.amazonq.lsp.artifacts.ArtifactManager
 import software.aws.toolkits.jetbrains.services.amazonq.lsp.flareChat.AsyncChatUiListener
 import software.aws.toolkits.jetbrains.services.amazonq.messages.AmazonQMessage
 import software.aws.toolkits.jetbrains.services.amazonq.messages.MessageConnector
@@ -105,7 +107,7 @@ class AmazonQPanel(val project: Project, private val scope: CoroutineScope) : Di
             wrapper.setContent(loadingPanel)
 
             ApplicationManager.getApplication().executeOnPooledThread {
-                val webUri = ArtifactHelper().getLatestLocalLspArtifact().resolve("amazonq-ui.js").toUri()
+                val webUri = runBlocking { service<ArtifactManager>().fetchArtifact(project).resolve("amazonq-ui.js").toUri() }
                 loadingPanel.stopLoading()
                 runInEdt {
                     browser.complete(
diff --git a/plugins/amazonq/chat/jetbrains-community/src/software/aws/toolkits/jetbrains/services/amazonq/webview/Browser.kt b/plugins/amazonq/chat/jetbrains-community/src/software/aws/toolkits/jetbrains/services/amazonq/webview/Browser.kt
index dba47f08e6c..2be84634929 100644
--- a/plugins/amazonq/chat/jetbrains-community/src/software/aws/toolkits/jetbrains/services/amazonq/webview/Browser.kt
+++ b/plugins/amazonq/chat/jetbrains-community/src/software/aws/toolkits/jetbrains/services/amazonq/webview/Browser.kt
@@ -116,6 +116,7 @@ class Browser(parent: Disposable, private val webUri: URI, val project: Project)
     ): String {
         val quickActionConfig = generateQuickActionConfig()
         val postMessageToJavaJsCode = receiveMessageQuery.inject("JSON.stringify(message)")
+        // language=HTML
         val jsScripts = """
             <script type="text/javascript" src="$webUri" defer onload="init()"></script>
             <script type="text/javascript">
diff --git a/plugins/amazonq/shared/jetbrains-community/src/software/aws/toolkits/jetbrains/services/amazonq/lsp/AmazonQLspService.kt b/plugins/amazonq/shared/jetbrains-community/src/software/aws/toolkits/jetbrains/services/amazonq/lsp/AmazonQLspService.kt
index aa2418fc2fa..7de94a494f7 100644
--- a/plugins/amazonq/shared/jetbrains-community/src/software/aws/toolkits/jetbrains/services/amazonq/lsp/AmazonQLspService.kt
+++ b/plugins/amazonq/shared/jetbrains-community/src/software/aws/toolkits/jetbrains/services/amazonq/lsp/AmazonQLspService.kt
@@ -266,7 +266,7 @@ private class AmazonQServerInstance(private val project: Project, private val cs
 
     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 { ArtifactManager(project, manifestRange = null).fetchArtifact() }.toAbsolutePath()
+        val artifact = runBlocking { service<ArtifactManager>().fetchArtifact(project) }.toAbsolutePath()
         val node = if (SystemInfo.isWindows) "node.exe" else "node"
         val cmd = GeneralCommandLine(
             artifact.resolve(node).toString(),
diff --git a/plugins/amazonq/shared/jetbrains-community/src/software/aws/toolkits/jetbrains/services/amazonq/lsp/artifacts/ArtifactHelper.kt b/plugins/amazonq/shared/jetbrains-community/src/software/aws/toolkits/jetbrains/services/amazonq/lsp/artifacts/ArtifactHelper.kt
index c6faba184a5..fea7d72ffbb 100644
--- a/plugins/amazonq/shared/jetbrains-community/src/software/aws/toolkits/jetbrains/services/amazonq/lsp/artifacts/ArtifactHelper.kt
+++ b/plugins/amazonq/shared/jetbrains-community/src/software/aws/toolkits/jetbrains/services/amazonq/lsp/artifacts/ArtifactHelper.kt
@@ -3,6 +3,7 @@
 
 package software.aws.toolkits.jetbrains.services.amazonq.lsp.artifacts
 
+import com.intellij.openapi.progress.ProgressManager
 import com.intellij.openapi.project.Project
 import com.intellij.platform.ide.progress.withBackgroundProgress
 import com.intellij.util.io.createDirectories
@@ -18,16 +19,14 @@ import software.aws.toolkits.core.utils.warn
 import software.aws.toolkits.jetbrains.core.saveFileFromUrl
 import software.aws.toolkits.jetbrains.services.amazonq.project.manifest.ManifestManager
 import software.aws.toolkits.resources.AwsCoreBundle
+import java.nio.file.Files
 import java.nio.file.Path
 import java.util.concurrent.atomic.AtomicInteger
 
-class ArtifactHelper(private val lspArtifactsPath: Path = DEFAULT_ARTIFACT_PATH, private val maxDownloadAttempts: Int = MAX_DOWNLOAD_ATTEMPTS) {
-
-    companion object {
-        private val DEFAULT_ARTIFACT_PATH = getToolkitsCommonCacheRoot().resolve("aws").resolve("toolkits").resolve("language-servers")
-        private val logger = getLogger<ArtifactHelper>()
-        private const val MAX_DOWNLOAD_ATTEMPTS = 3
-    }
+class ArtifactHelper internal constructor(
+    private val lspArtifactsPath: Path = DEFAULT_ARTIFACT_PATH,
+    private val maxDownloadAttempts: Int = MAX_DOWNLOAD_ATTEMPTS,
+) {
     private val currentAttempt = AtomicInteger(0)
 
     fun removeDelistedVersions(delistedVersions: List<ManifestManager.Version>) {
@@ -79,16 +78,6 @@ class ArtifactHelper(private val lspArtifactsPath: Path = DEFAULT_ARTIFACT_PATH,
             .sortedByDescending { (_, semVer) -> semVer }
     }
 
-    fun getLatestLocalLspArtifact(): Path {
-        val localFolders = getSubFolders(lspArtifactsPath)
-        return localFolders.map { localFolder ->
-            localFolder to SemVer.parseFromText(localFolder.fileName.toString())
-        }
-            .sortedByDescending { (_, semVer) -> semVer }
-            .first()
-            .first
-    }
-
     fun getExistingLspArtifacts(versions: List<ManifestManager.Version>, target: ManifestManager.VersionTarget?): Boolean {
         if (versions.isEmpty() || target?.contents == null) return false
 
@@ -114,7 +103,7 @@ class ArtifactHelper(private val lspArtifactsPath: Path = DEFAULT_ARTIFACT_PATH,
     }
 
     suspend fun tryDownloadLspArtifacts(project: Project, versions: List<ManifestManager.Version>, target: ManifestManager.VersionTarget?): Path? {
-        val temporaryDownloadPath = lspArtifactsPath.resolve("temp")
+        val temporaryDownloadPath = Files.createTempDirectory("lsp-dl")
         val downloadPath = lspArtifactsPath.resolve(versions.first().serverVersion.toString())
 
         while (currentAttempt.get() < maxDownloadAttempts) {
@@ -188,7 +177,7 @@ class ArtifactHelper(private val lspArtifactsPath: Path = DEFAULT_ARTIFACT_PATH,
         try {
             if (!filePath.exists()) {
                 logger.info { "Downloading file: ${filePath.fileName}" }
-                saveFileFromUrl(url, filePath)
+                saveFileFromUrl(url, filePath, ProgressManager.getInstance().progressIndicator)
             }
             if (!validateFileHash(filePath, expectedHash)) {
                 logger.warn { "Hash mismatch for ${filePath.fileName}, re-downloading" }
@@ -222,4 +211,10 @@ class ArtifactHelper(private val lspArtifactsPath: Path = DEFAULT_ARTIFACT_PATH,
             throw LspException(errorMessage, LspException.ErrorCode.DOWNLOAD_FAILED)
         }
     }
+
+    companion object {
+        private val DEFAULT_ARTIFACT_PATH = getToolkitsCommonCacheRoot().resolve("aws").resolve("toolkits").resolve("language-servers")
+        private val logger = getLogger<ArtifactHelper>()
+        private const val MAX_DOWNLOAD_ATTEMPTS = 3
+    }
 }
diff --git a/plugins/amazonq/shared/jetbrains-community/src/software/aws/toolkits/jetbrains/services/amazonq/lsp/artifacts/ArtifactManager.kt b/plugins/amazonq/shared/jetbrains-community/src/software/aws/toolkits/jetbrains/services/amazonq/lsp/artifacts/ArtifactManager.kt
index 2f25ecc9da1..833776378a7 100644
--- a/plugins/amazonq/shared/jetbrains-community/src/software/aws/toolkits/jetbrains/services/amazonq/lsp/artifacts/ArtifactManager.kt
+++ b/plugins/amazonq/shared/jetbrains-community/src/software/aws/toolkits/jetbrains/services/amazonq/lsp/artifacts/ArtifactManager.kt
@@ -3,8 +3,15 @@
 
 package software.aws.toolkits.jetbrains.services.amazonq.lsp.artifacts
 
+import com.intellij.openapi.components.Service
 import com.intellij.openapi.project.Project
+import com.intellij.serviceContainer.NonInjectable
 import com.intellij.util.text.SemVer
+import kotlinx.coroutines.Deferred
+import kotlinx.coroutines.async
+import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
 import org.jetbrains.annotations.VisibleForTesting
 import software.aws.toolkits.core.utils.error
 import software.aws.toolkits.core.utils.getLogger
@@ -12,12 +19,16 @@ import software.aws.toolkits.core.utils.info
 import software.aws.toolkits.jetbrains.services.amazonq.project.manifest.ManifestManager
 import java.nio.file.Path
 
-class ArtifactManager(
-    private val project: Project,
-    private val manifestFetcher: ManifestFetcher = ManifestFetcher(),
-    private val artifactHelper: ArtifactHelper = ArtifactHelper(),
-    manifestRange: SupportedManifestVersionRange?,
-) {
+@Service
+class ArtifactManager @NonInjectable internal constructor(private val manifestFetcher: ManifestFetcher, private val artifactHelper: ArtifactHelper) {
+    constructor() : this(
+        ManifestFetcher(),
+        ArtifactHelper()
+    )
+
+    // we currently cannot handle the versions swithing in the middle of a user's session
+    private val mutex = Mutex()
+    private var artifactDeferred: Deferred<Path>? = null
 
     data class SupportedManifestVersionRange(
         val startVersion: SemVer,
@@ -28,8 +39,6 @@ class ArtifactManager(
         val inRangeVersions: List<ManifestManager.Version>,
     )
 
-    private val manifestVersionRanges: SupportedManifestVersionRange = manifestRange ?: DEFAULT_VERSION_RANGE
-
     companion object {
         private val DEFAULT_VERSION_RANGE = SupportedManifestVersionRange(
             startVersion = SemVer("0.0.0", 0, 0, 0),
@@ -38,35 +47,47 @@ class ArtifactManager(
         private val logger = getLogger<ArtifactManager>()
     }
 
-    suspend fun fetchArtifact(): Path {
-        val manifest = manifestFetcher.fetch() ?: throw LspException(
-            "Language Support is not available, as manifest is missing.",
-            LspException.ErrorCode.MANIFEST_FETCH_FAILED
-        )
-        val lspVersions = getLSPVersionsFromManifestWithSpecifiedRange(manifest)
+    suspend fun fetchArtifact(project: Project): Path {
+        mutex.withLock { artifactDeferred }?.let {
+            return it.await()
+        }
 
-        this.artifactHelper.removeDelistedVersions(lspVersions.deListedVersions)
+        return mutex.withLock {
+            coroutineScope {
+                async {
+                    val manifest = manifestFetcher.fetch() ?: throw LspException(
+                        "Language Support is not available, as manifest is missing.",
+                        LspException.ErrorCode.MANIFEST_FETCH_FAILED
+                    )
+                    val lspVersions = getLSPVersionsFromManifestWithSpecifiedRange(manifest)
 
-        if (lspVersions.inRangeVersions.isEmpty()) {
-            // No versions are found which are in the given range. Fallback to local lsp artifacts.
-            val localLspArtifacts = this.artifactHelper.getAllLocalLspArtifactsWithinManifestRange(manifestVersionRanges)
-            if (localLspArtifacts.isNotEmpty()) {
-                return localLspArtifacts.first().first
-            }
-            throw LspException("Language server versions not found in manifest.", LspException.ErrorCode.NO_COMPATIBLE_LSP_VERSION)
-        }
+                    artifactHelper.removeDelistedVersions(lspVersions.deListedVersions)
 
-        // If there is an LSP Manifest with the same version
-        val target = getTargetFromLspManifest(lspVersions.inRangeVersions)
-        // Get Local LSP files and check if we can re-use existing LSP Artifacts
-        val artifactPath: Path = if (this.artifactHelper.getExistingLspArtifacts(lspVersions.inRangeVersions, target)) {
-            this.artifactHelper.getAllLocalLspArtifactsWithinManifestRange(manifestVersionRanges).first().first
-        } else {
-            this.artifactHelper.tryDownloadLspArtifacts(project, lspVersions.inRangeVersions, target)
-                ?: throw LspException("Failed to download LSP artifacts", LspException.ErrorCode.DOWNLOAD_FAILED)
-        }
-        this.artifactHelper.deleteOlderLspArtifacts(manifestVersionRanges)
-        return artifactPath
+                    if (lspVersions.inRangeVersions.isEmpty()) {
+                        // No versions are found which are in the given range. Fallback to local lsp artifacts.
+                        val localLspArtifacts = artifactHelper.getAllLocalLspArtifactsWithinManifestRange(DEFAULT_VERSION_RANGE)
+                        if (localLspArtifacts.isNotEmpty()) {
+                            return@async localLspArtifacts.first().first
+                        }
+                        throw LspException("Language server versions not found in manifest.", LspException.ErrorCode.NO_COMPATIBLE_LSP_VERSION)
+                    }
+
+                    // If there is an LSP Manifest with the same version
+                    val target = getTargetFromLspManifest(lspVersions.inRangeVersions)
+                    // Get Local LSP files and check if we can re-use existing LSP Artifacts
+                    val artifactPath: Path = if (artifactHelper.getExistingLspArtifacts(lspVersions.inRangeVersions, target)) {
+                        artifactHelper.getAllLocalLspArtifactsWithinManifestRange(DEFAULT_VERSION_RANGE).first().first
+                    } else {
+                        artifactHelper.tryDownloadLspArtifacts(project, lspVersions.inRangeVersions, target)
+                            ?: throw LspException("Failed to download LSP artifacts", LspException.ErrorCode.DOWNLOAD_FAILED)
+                    }
+                    artifactHelper.deleteOlderLspArtifacts(DEFAULT_VERSION_RANGE)
+                    return@async artifactPath
+                }
+            }.also {
+                artifactDeferred = it
+            }
+        }.await()
     }
 
     @VisibleForTesting
@@ -78,7 +99,7 @@ class ArtifactManager(
                 SemVer.parseFromText(serverVersion)?.let { semVer ->
                     when {
                         version.isDelisted != false -> Pair(version, true) // Is deListed
-                        semVer in manifestVersionRanges.startVersion..manifestVersionRanges.endVersion -> Pair(version, false) // Is in range
+                        semVer in DEFAULT_VERSION_RANGE.let { it.startVersion..it.endVersion } -> Pair(version, false) // Is in range
                         else -> null
                     }
                 }
diff --git a/plugins/amazonq/shared/jetbrains-community/tst/software/aws/toolkits/jetbrains/services/amazonq/lsp/artifacts/ArtifactManagerTest.kt b/plugins/amazonq/shared/jetbrains-community/tst/software/aws/toolkits/jetbrains/services/amazonq/lsp/artifacts/ArtifactManagerTest.kt
index 4e163900bff..ae68c99d740 100644
--- a/plugins/amazonq/shared/jetbrains-community/tst/software/aws/toolkits/jetbrains/services/amazonq/lsp/artifacts/ArtifactManagerTest.kt
+++ b/plugins/amazonq/shared/jetbrains-community/tst/software/aws/toolkits/jetbrains/services/amazonq/lsp/artifacts/ArtifactManagerTest.kt
@@ -3,28 +3,33 @@
 
 package software.aws.toolkits.jetbrains.services.amazonq.lsp.artifacts
 
-import com.intellij.openapi.project.Project
+import com.intellij.testFramework.ProjectExtension
 import com.intellij.util.text.SemVer
 import io.mockk.Runs
 import io.mockk.coEvery
+import io.mockk.coVerify
 import io.mockk.every
 import io.mockk.just
-import io.mockk.mockk
 import io.mockk.mockkStatic
 import io.mockk.spyk
 import io.mockk.verify
-import kotlinx.coroutines.runBlocking
-import org.assertj.core.api.Assertions.assertThatThrownBy
-import org.jetbrains.annotations.TestOnly
+import kotlinx.coroutines.test.runTest
+import org.assertj.core.api.Assertions.assertThat
 import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.assertThrows
+import org.junit.jupiter.api.extension.RegisterExtension
 import org.junit.jupiter.api.io.TempDir
 import software.aws.toolkits.jetbrains.services.amazonq.lsp.artifacts.ArtifactManager.SupportedManifestVersionRange
 import software.aws.toolkits.jetbrains.services.amazonq.project.manifest.ManifestManager
 import java.nio.file.Path
 
-@TestOnly
 class ArtifactManagerTest {
+    companion object {
+        @JvmField
+        @RegisterExtension
+        val projectExtension = ProjectExtension()
+    }
 
     @TempDir
     lateinit var tempDir: Path
@@ -33,7 +38,6 @@ class ArtifactManagerTest {
     private lateinit var artifactManager: ArtifactManager
     private lateinit var manifestFetcher: ManifestFetcher
     private lateinit var manifestVersionRanges: SupportedManifestVersionRange
-    private lateinit var mockProject: Project
 
     @BeforeEach
     fun setUp() {
@@ -43,60 +47,54 @@ class ArtifactManagerTest {
             startVersion = SemVer("1.0.0", 1, 0, 0),
             endVersion = SemVer("2.0.0", 2, 0, 0)
         )
-        mockProject = mockk<Project>(relaxed = true) {
-            every { basePath } returns tempDir.toString()
-            every { name } returns "TestProject"
-        }
-        artifactManager = ArtifactManager(mockProject, manifestFetcher, artifactHelper, manifestVersionRanges)
+
+        artifactManager = spyk(ArtifactManager(manifestFetcher, artifactHelper))
     }
 
     @Test
-    fun `fetch artifact fetcher throws exception if manifest is null`() {
+    fun `fetch artifact fetcher throws exception if manifest is null`() = runTest {
         every { manifestFetcher.fetch() }.returns(null)
 
-        assertThatThrownBy {
-            runBlocking { artifactManager.fetchArtifact() }
+        val exception = assertThrows<LspException> {
+            artifactManager.fetchArtifact(projectExtension.project)
         }
-            .isInstanceOf(LspException::class.java)
+        assertThat(exception)
             .hasFieldOrPropertyWithValue("errorCode", LspException.ErrorCode.MANIFEST_FETCH_FAILED)
     }
 
     @Test
-    fun `fetch artifact does not have any valid lsp versions`() {
+    fun `fetch artifact does not have any valid lsp versions`() = runTest {
         every { manifestFetcher.fetch() }.returns(ManifestManager.Manifest())
-        artifactManager = spyk(ArtifactManager(mockProject, manifestFetcher, artifactHelper, manifestVersionRanges))
 
         every { artifactManager.getLSPVersionsFromManifestWithSpecifiedRange(any()) }.returns(
             ArtifactManager.LSPVersions(deListedVersions = emptyList(), inRangeVersions = emptyList())
         )
 
-        assertThatThrownBy {
-            runBlocking { artifactManager.fetchArtifact() }
+        val exception = assertThrows<LspException> {
+            artifactManager.fetchArtifact(projectExtension.project)
         }
-            .isInstanceOf(LspException::class.java)
+        assertThat(exception)
             .hasFieldOrPropertyWithValue("errorCode", LspException.ErrorCode.NO_COMPATIBLE_LSP_VERSION)
     }
 
     @Test
-    fun `fetch artifact if inRangeVersions are not available should fallback to local lsp`() {
+    fun `fetch artifact if inRangeVersions are not available should fallback to local lsp`() = runTest {
         val expectedResult = listOf(Pair(tempDir, SemVer("1.0.0", 1, 0, 0)))
 
         every { manifestFetcher.fetch() }.returns(ManifestManager.Manifest())
         every { artifactHelper.getAllLocalLspArtifactsWithinManifestRange(any()) }.returns(expectedResult)
 
-        runBlocking { artifactManager.fetchArtifact() }
+        artifactManager.fetchArtifact(projectExtension.project)
 
         verify(exactly = 1) { manifestFetcher.fetch() }
         verify(exactly = 1) { artifactHelper.getAllLocalLspArtifactsWithinManifestRange(any()) }
     }
 
     @Test
-    fun `fetch artifact have valid version in local system`() {
+    fun `fetch artifact have valid version in local system`() = runTest {
         val target = ManifestManager.VersionTarget(platform = "temp", arch = "temp")
         val versions = listOf(ManifestManager.Version("1.0.0", targets = listOf(target)))
 
-        artifactManager = spyk(ArtifactManager(mockProject, manifestFetcher, artifactHelper, manifestVersionRanges))
-
         every { artifactManager.getLSPVersionsFromManifestWithSpecifiedRange(any()) }.returns(
             ArtifactManager.LSPVersions(deListedVersions = emptyList(), inRangeVersions = versions)
         )
@@ -110,20 +108,18 @@ class ArtifactManagerTest {
         coEvery { artifactHelper.tryDownloadLspArtifacts(any(), any(), any()) } returns tempDir
         every { artifactHelper.deleteOlderLspArtifacts(any()) } just Runs
 
-        runBlocking { artifactManager.fetchArtifact() }
+        artifactManager.fetchArtifact(projectExtension.project)
 
-        verify(exactly = 1) { runBlocking { artifactHelper.tryDownloadLspArtifacts(any(), any(), any()) } }
+        coVerify(exactly = 1) { artifactHelper.tryDownloadLspArtifacts(any(), any(), any()) }
         verify(exactly = 1) { artifactHelper.deleteOlderLspArtifacts(any()) }
     }
 
     @Test
-    fun `fetch artifact does not have valid version in local system`() {
+    fun `fetch artifact does not have valid version in local system`() = runTest {
         val target = ManifestManager.VersionTarget(platform = "temp", arch = "temp")
         val versions = listOf(ManifestManager.Version("1.0.0", targets = listOf(target)))
         val expectedResult = listOf(Pair(tempDir, SemVer("1.0.0", 1, 0, 0)))
 
-        artifactManager = spyk(ArtifactManager(mockProject, manifestFetcher, artifactHelper, manifestVersionRanges))
-
         every { artifactManager.getLSPVersionsFromManifestWithSpecifiedRange(any()) }.returns(
             ArtifactManager.LSPVersions(deListedVersions = emptyList(), inRangeVersions = versions)
         )
@@ -137,9 +133,9 @@ class ArtifactManagerTest {
         every { artifactHelper.deleteOlderLspArtifacts(any()) } just Runs
         every { artifactHelper.getAllLocalLspArtifactsWithinManifestRange(any()) }.returns(expectedResult)
 
-        runBlocking { artifactManager.fetchArtifact() }
+        artifactManager.fetchArtifact(projectExtension.project)
 
-        verify(exactly = 0) { runBlocking { artifactHelper.tryDownloadLspArtifacts(any(), any(), any()) } }
+        coVerify(exactly = 0) { artifactHelper.tryDownloadLspArtifacts(any(), any(), any()) }
         verify(exactly = 1) { artifactHelper.deleteOlderLspArtifacts(any()) }
     }
 }
diff --git a/plugins/core/resources/resources/software/aws/toolkits/resources/MessagesBundle.properties b/plugins/core/resources/resources/software/aws/toolkits/resources/MessagesBundle.properties
index c7e667e7bc8..81a1e774b75 100644
--- a/plugins/core/resources/resources/software/aws/toolkits/resources/MessagesBundle.properties
+++ b/plugins/core/resources/resources/software/aws/toolkits/resources/MessagesBundle.properties
@@ -141,7 +141,7 @@ amazonqFeatureDev.placeholder.after_code_generation=Choose an option to proceed
 amazonqFeatureDev.placeholder.after_monthly_limit=Chat input is disabled
 amazonqFeatureDev.placeholder.closed_session=Open a new chat tab to continue
 amazonqFeatureDev.placeholder.context_gathering_complete=Gathering context...
-amazonqFeatureDev.placeholder.downloading_and_extracting_lsp_artifacts=Downloading and Extracting Lsp Artifacts...
+amazonqFeatureDev.placeholder.downloading_and_extracting_lsp_artifacts=Downloading and Extracting LSP Artifacts...
 amazonqFeatureDev.placeholder.generating_code=Generating code...
 amazonqFeatureDev.placeholder.lsp=LSP
 amazonqFeatureDev.placeholder.new_plan=Describe your task or issue in as much detail as possible