diff --git a/crates/dap_adapters/src/go.rs b/crates/dap_adapters/src/go.rs
index af81f5cca5390d7e72e1805331e25da0a036d9d8..93d0e8a958568cd7899208daca05a9c1dd2f846b 100644
--- a/crates/dap_adapters/src/go.rs
+++ b/crates/dap_adapters/src/go.rs
@@ -8,6 +8,7 @@ use dap::{
     },
 };
 use fs::Fs;
+use futures::StreamExt;
 use gpui::{AsyncApp, SharedString};
 use language::LanguageName;
 use log::warn;
@@ -71,27 +72,59 @@ impl GoDebugAdapter {
             return Ok(path);
         }
 
-        let asset = Self::fetch_latest_adapter_version(delegate).await?;
-        let ty = if consts::OS == "windows" {
-            DownloadedFileType::Zip
-        } else {
-            DownloadedFileType::GzipTar
-        };
-        download_adapter_from_github(
-            "delve-shim-dap".into(),
-            asset.clone(),
-            ty,
-            delegate.as_ref(),
-        )
-        .await?;
+        let adapter_dir = paths::debug_adapters_dir().join("delve-shim-dap");
+
+        match Self::fetch_latest_adapter_version(delegate).await {
+            Ok(asset) => {
+                let ty = if consts::OS == "windows" {
+                    DownloadedFileType::Zip
+                } else {
+                    DownloadedFileType::GzipTar
+                };
+                download_adapter_from_github(
+                    "delve-shim-dap".into(),
+                    asset.clone(),
+                    ty,
+                    delegate.as_ref(),
+                )
+                .await?;
+
+                let path = adapter_dir
+                    .join(format!("delve-shim-dap_{}", asset.tag_name))
+                    .join(format!("delve-shim-dap{}", consts::EXE_SUFFIX));
+                self.shim_path.set(path.clone()).ok();
 
-        let path = paths::debug_adapters_dir()
-            .join("delve-shim-dap")
-            .join(format!("delve-shim-dap_{}", asset.tag_name))
-            .join(format!("delve-shim-dap{}", std::env::consts::EXE_SUFFIX));
-        self.shim_path.set(path.clone()).ok();
+                Ok(path)
+            }
+            Err(error) => {
+                let binary_name = format!("delve-shim-dap{}", consts::EXE_SUFFIX);
+                let mut cached = None;
+                if let Ok(mut entries) = delegate.fs().read_dir(&adapter_dir).await {
+                    while let Some(entry) = entries.next().await {
+                        if let Ok(version_dir) = entry {
+                            let candidate = version_dir.join(&binary_name);
+                            if delegate
+                                .fs()
+                                .metadata(&candidate)
+                                .await
+                                .is_ok_and(|m| m.is_some())
+                            {
+                                cached = Some(candidate);
+                                break;
+                            }
+                        }
+                    }
+                }
 
-        Ok(path)
+                if let Some(path) = cached {
+                    warn!("Failed to fetch latest delve-shim-dap, using cached version: {error:#}");
+                    self.shim_path.set(path.clone()).ok();
+                    Ok(path)
+                } else {
+                    Err(error)
+                }
+            }
+        }
     }
 }
 
diff --git a/crates/dap_adapters/src/python.rs b/crates/dap_adapters/src/python.rs
index 96bdde12672cae471edf1d6e603a06413d1f4b21..111eab5a1d1bf4dea5f99ce83c01ce8fdb9e47e3 100644
--- a/crates/dap_adapters/src/python.rs
+++ b/crates/dap_adapters/src/python.rs
@@ -224,16 +224,27 @@ impl PythonDebugAdapter {
     ) -> Result<Arc<Path>, String> {
         self.debugpy_whl_base_path
             .get_or_init(|| async move {
-                self.maybe_fetch_new_wheel(toolchain, delegate)
-                    .await
-                    .map_err(|e| format!("{e}"))?;
-                Ok(Arc::from(
-                    debug_adapters_dir()
-                        .join(Self::ADAPTER_NAME)
-                        .join("debugpy")
-                        .join("adapter")
-                        .as_ref(),
-                ))
+                let adapter_path = debug_adapters_dir()
+                    .join(Self::ADAPTER_NAME)
+                    .join("debugpy")
+                    .join("adapter");
+
+                if let Err(error) = self.maybe_fetch_new_wheel(toolchain, delegate).await {
+                    if delegate
+                        .fs()
+                        .metadata(&adapter_path)
+                        .await
+                        .is_ok_and(|m| m.is_some())
+                    {
+                        log::warn!(
+                            "Failed to fetch latest debugpy, using cached version: {error:#}"
+                        );
+                    } else {
+                        return Err(format!("{error}"));
+                    }
+                }
+
+                Ok(Arc::from(adapter_path.as_ref()))
             })
             .await
             .clone()