chore(hf): upgrade xet-core to 126f30b9 with per-operation token API

Migrate to the latest xet-core API where CAS auth tokens move from
session-level to per-operation (UploadCommitBuilder/DownloadStreamGroupBuilder).
Use token refresh URLs so xet-core manages JWT lifecycle automatically.

Author: kszucs

core/services/hf/Cargo.toml

@@ -45,7 +45,7 @@ reqwest = { version = "0.12", default-features = false, features = [
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
 tokio = { workspace = true, features = ["sync"] }
-hf-xet = { git = "https://github.com/huggingface/xet-core.git", rev = "60a916f74df506a5d10c0656ee3e86a8411ab4f6" }
+hf-xet = { git = "https://github.com/huggingface/xet-core.git", rev = "126f30b9816b7cc737f38c02017867264472c933" }
 
 [dev-dependencies]
 opendal-core = { path = "../../core", version = "0.55.0", features = [

core/services/hf/src/core.rs

@@ -173,9 +173,7 @@ pub(super) struct LastCommit {
 #[derive(Clone, Debug, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub(super) struct XetToken {
-    pub access_token: String,
     pub cas_url: String,
-    pub exp: u64,
 }
 
 // Core HuggingFace client that manages API interactions, authentication
@@ -322,10 +320,9 @@ impl HfCore {
         let this = self.clone();
         self.xet_session
             .get_or_try_init(|| async move {
-                let token = this.xet_token("write").await?;
+                let token = this.xet_token("read").await?;
                 XetSessionBuilder::new()
                     .with_endpoint(token.cas_url)
-                    .with_token_info(token.access_token, token.exp)
                     .build()
                     .map_err(|err| {
                         Error::new(ErrorKind::Unexpected, "failed to create xet session")
@@ -336,6 +333,17 @@ impl HfCore {
             .cloned()
     }
 
+    /// Build an HTTP HeaderMap with the Authorization header for XET token refresh.
+    pub(super) fn xet_token_refresh_headers(&self) -> http::HeaderMap {
+        let mut headers = http::HeaderMap::new();
+        if let Some(token) = &self.token {
+            if let Ok(val) = format!("Bearer {}", token).parse() {
+                headers.insert(header::AUTHORIZATION, val);
+            }
+        }
+        headers
+    }
+
     /// Issue a HEAD request and extract XET file info (hash and size).
     ///
     /// Returns `None` if the `X-Xet-Hash` header is absent or empty.

core/services/hf/src/reader.rs

@@ -84,19 +84,46 @@ impl HfReader {
         range: BytesRange,
     ) -> Result<Self> {
         let session = core.xet_session().await?;
+        let refresh_url = core.repo.xet_token_url(&core.endpoint, "read");
+        let refresh_headers = core.xet_token_refresh_headers();
+
+        let group = session
+            .new_download_stream_group()
+            .map_err(|err| {
+                Error::new(
+                    ErrorKind::Unexpected,
+                    "failed to create download stream group",
+                )
+                .set_source(err)
+            })?
+            .with_token_refresh_url(refresh_url, refresh_headers)
+            .build()
+            .await
+            .map_err(|err| {
+                Error::new(
+                    ErrorKind::Unexpected,
+                    "failed to build download stream group",
+                )
+                .set_source(err)
+            })?;
+
         let xet_range = if range.is_full() {
             None
         } else {
             let start = range.offset();
             let end = range.size().map(|s| start + s).unwrap_or(u64::MAX);
             Some(start..end)
         };
-        let mut stream = session
+
+        let mut stream = group
             .download_stream(file_info.clone(), xet_range)
             .await
             .map_err(|err| {
-                Error::new(ErrorKind::Unexpected, "failed to create xet download stream")
-                    .set_source(err)
+                Error::new(
+                    ErrorKind::Unexpected,
+                    "failed to create xet download stream",
+                )
+                .set_source(err)
             })?;
         stream.start();
         Ok(Self::Xet(stream))

core/services/hf/src/writer.rs

@@ -52,10 +52,22 @@ impl HfWriter {
 
         let writer = if use_xet {
             let session = core.xet_session().await?;
-            let commit = session.new_upload_commit().await.map_err(|err| {
-                Error::new(ErrorKind::Unexpected, "failed to create xet upload commit")
-                    .set_source(err)
-            })?;
+            let refresh_url = core.repo.xet_token_url(&core.endpoint, "write");
+            let refresh_headers = core.xet_token_refresh_headers();
+
+            let commit = session
+                .new_upload_commit()
+                .map_err(|err| {
+                    Error::new(ErrorKind::Unexpected, "failed to create xet upload commit")
+                        .set_source(err)
+                })?
+                .with_token_refresh_url(refresh_url, refresh_headers)
+                .build()
+                .await
+                .map_err(|err| {
+                    Error::new(ErrorKind::Unexpected, "failed to build xet upload commit")
+                        .set_source(err)
+                })?;
             let stream = commit
                 .upload_stream(None, Sha256Policy::Compute)
                 .await
@@ -131,9 +143,9 @@ impl oio::Write for HfWriter {
                 commit,
                 stream,
             } => {
-                let stream = stream
-                    .take()
-                    .ok_or_else(|| Error::new(ErrorKind::Unexpected, "xet writer already closed"))?;
+                let stream = stream.take().ok_or_else(|| {
+                    Error::new(ErrorKind::Unexpected, "xet writer already closed")
+                })?;
 
                 let file_meta = stream.finish().await.map_err(|err| {
                     Error::new(ErrorKind::Unexpected, "failed to finish xet upload").set_source(err)
@@ -145,8 +157,7 @@ impl oio::Write for HfWriter {
                 let meta = Metadata::default().with_content_length(content_length);
 
                 commit.commit().await.map_err(|err| {
-                    Error::new(ErrorKind::Unexpected, "failed to commit xet upload")
-                        .set_source(err)
+                    Error::new(ErrorKind::Unexpected, "failed to commit xet upload").set_source(err)
                 })?;
 
                 if core.repo.repo_type == RepoType::Bucket {