--- a/Cargo.toml
+++ b/Cargo.toml
@@ -158,25 +158,20 @@ version = "1.0.229"
 version = "1.0.229"
 
 [dependencies.tame-index]
-version = "0.27.0"
+version = "0.26.0"
+features = [
+    "sparse",
+    "local",
+]
 
 [dependencies.termcolor]
 version = "1.4.1"
 
 [dependencies.toml]
-version = "1.1.8"
+version = "1.1.6"
 
 [dependencies.toml_edit]
-version = "0.25.17"
-
-[dependencies.ureq]
-version = "3.5"
-features = [
-    "platform-verifier",
-    "rustls",
-    "rustls-webpki-roots",
-]
-default-features = false
+version = "0.25.15"
 
 [dependencies.url]
 version = "2.5.8"
@@ -185,14 +180,14 @@ version = "2.5.8"
 version = "0.11.6"
 
 [dev-dependencies.snapbox]
-version = "1.2.2"
+version = "0.6.21"
 features = [
     "cmd",
     "path",
 ]
 
 [dev-dependencies.trycmd]
-version = "1.2.1"
+version = "0.15"
 
 [lints.clippy]
 bool_assert_comparison = "allow"
--- a/src/index.rs
+++ b/src/index.rs
@@ -1,5 +1,5 @@
-use tame_index::flock::FileLock;
 use tame_index::krate::IndexKrate;
+use tame_index::utils::flock::FileLock;
 
 use url::Url;
 
@@ -143,7 +143,8 @@ impl AnyIndex {
 }
 
 struct LocalIndex {
-    index: tame_index::index::LocalIndex,
+    index: tame_index::index::LocalRegistry,
+    root: tame_index::PathBuf,
 }
 
 impl LocalIndex {
@@ -153,49 +154,48 @@ impl LocalIndex {
             .map_err(|_err| anyhow::format_err!("invalid file path {url:?}"))?;
         let path = tame_index::PathBuf::from_path_buf(path)
             .map_err(|_err| anyhow::format_err!("invalid file path {url:?}"))?;
-        Ok(Self {
-            index: tame_index::index::LocalIndex::open(path)?,
-        })
+        let index = tame_index::index::LocalRegistry::open(path.clone(), false)?;
+        Ok(Self { index, root: path })
     }
 
     fn krate(&mut self, name: &str) -> CargoResult<Option<IndexKrate>> {
-        let l = FileLock::unlocked();
-        let Some(entry) = self.index.krate(name.try_into()?, &l)? else {
+        let name = tame_index::KrateName::cargo(name)?;
+        // HACK: for some reason, `tame_index` puts `index` in the middle
+        let entry_path = self.index.krate_path(name);
+        let rel_path = entry_path
+            .strip_prefix(&self.root)
+            .map_err(|_err| anyhow::format_err!("invalid index path {entry_path:?}"))?;
+        let rel_path = rel_path
+            .strip_prefix("index")
+            .map_err(|_err| anyhow::format_err!("invalid index path {entry_path:?}"))?;
+        let entry_path = self.root.join(rel_path);
+        let Ok(entry) = std::fs::read(&entry_path) else {
             return Ok(None);
         };
-
-        Ok(entry.deserialize().map(Some)?)
+        let results = IndexKrate::from_slice(&entry)?;
+        Ok(Some(results))
     }
 }
 
 struct RemoteIndex {
     index: tame_index::SparseIndex,
-    client: ureq::Agent,
+    client: tame_index::external::reqwest::blocking::Client,
     lock: FileLock,
-    etag_cache: tame_index::EtagCache,
+    etags: Vec<(String, String)>,
 }
 
 impl RemoteIndex {
-    fn open(url: &Url, certs_source: CertsSource) -> CargoResult<Self> {
+    fn open(url: &Url, _certs_source: CertsSource) -> CargoResult<Self> {
         log::trace!("opening index entry for {url}");
         let url = url.to_string();
         let url = tame_index::IndexUrl::NonCratesIo(std::borrow::Cow::Owned(url));
         let index = tame_index::SparseIndex::new(tame_index::IndexLocation::new(url))?;
 
-        let client = ureq::Agent::config_builder()
-            // tame_index handles HTTP status codes internally
-            .http_status_as_error(false)
-            .tls_config(
-                ureq::tls::TlsConfig::builder()
-                    .provider(ureq::tls::TlsProvider::Rustls)
-                    .root_certs(match certs_source {
-                        CertsSource::Webpki => ureq::tls::RootCerts::WebPki,
-                        CertsSource::Native => ureq::tls::RootCerts::PlatformVerifier,
-                    })
-                    .build(),
-            )
-            .build()
-            .new_agent();
+        let client = {
+            let builder = tame_index::external::reqwest::blocking::ClientBuilder::new();
+
+            builder.build()?
+        };
 
         let lock = FileLock::unlocked();
 
@@ -203,35 +203,66 @@ impl RemoteIndex {
             index,
             client,
             lock,
-            etag_cache: Default::default(),
+            etags: Vec::new(),
         })
     }
 
     fn krate(&mut self, name: &str) -> CargoResult<Option<IndexKrate>> {
         log::trace!("krate {name}");
+        let etag = self
+            .etags
+            .iter()
+            .find_map(|(krate, etag)| (krate == name).then_some(etag.as_str()))
+            .unwrap_or("");
+
         let krate_name = name.try_into()?;
         let req = self
-            .etag_cache
-            .make_remote_request(&self.index, krate_name, &self.lock)?;
+            .index
+            .make_remote_request(krate_name, Some(etag), &self.lock)?;
+        let (
+            tame_index::external::http::request::Parts {
+                method,
+                uri,
+                version,
+                headers,
+                ..
+            },
+            _,
+        ) = req.into_parts();
+        let mut req = self.client.request(method, uri.to_string());
+        req = req.version(version);
+        req = req.headers(headers);
+        let res = self.client.execute(req.build()?)?;
+
+        // Grab the etag if it exists for future requests
+        if let Some(etag) = res
+            .headers()
+            .get(tame_index::external::reqwest::header::ETAG)
+            && let Ok(etag) = etag.to_str()
+        {
+            if let Some(i) = self.etags.iter().position(|(krate, _)| krate == name) {
+                etag.clone_into(&mut self.etags[i].1);
+            } else {
+                self.etags.push((name.to_owned(), etag.to_owned()));
+            }
+        }
 
-        let (parts, mut body) = self.client.run(req.into())?.into_parts();
-        let body = body.read_to_vec().context("failed to read response body")?;
+        let mut builder = tame_index::external::http::Response::builder()
+            .status(res.status())
+            .version(res.version());
+
+        builder
+            .headers_mut()
+            .unwrap()
+            .extend(res.headers().iter().map(|(k, v)| (k.clone(), v.clone())));
+
+        let body = res.bytes()?;
+        let response = builder
+            .body(body.to_vec())
+            .map_err(|e| tame_index::Error::from(tame_index::error::HttpError::from(e)))?;
 
-        self.etag_cache
-            .parse_remote_response(
-                &self.index,
-                krate_name,
-                &ureq::http::Response::from_parts(parts, body),
-                false,
-                &self.lock,
-            )
-            .and_then(|ie| {
-                if let Some(ie) = ie {
-                    ie.deserialize().map(Some)
-                } else {
-                    Ok(None)
-                }
-            })
+        self.index
+            .parse_remote_response(krate_name, response, false, &self.lock)
             .map_err(Into::into)
     }
 }
