bugfix for upload_blob()

CHANGELOG.md

···
 # Changelog
 
+
+## [0.5.4] - 2025-10-16
+
+### Added
+
+**Initial streaming client support** (`jacquard-common`)
+- First primitives for streamed requests and responses
+
+**`send_with_options()` method on XrpcClient** (`jacquard-common`, `jacquard-oauth`, `jacquard`)
+- allows setting custom options per request in stateful client
+- updated oauth and credential session clients to use it
+- implementations should generally override provided auth with own internal auth
+
+### Fixed
+
+**`AgentSessionExt::upload_blob()` failed to authenticate** (`jacquard`)
+- new `XrpcClient::send_with_options()` method now allows properly overriding the content-type header while still handling auth internally
+
 ## [0.5.3] - 2025-10-15
 
 ### Added

Cargo.lock

···
 
 [[package]]
 name = "jacquard"
-version = "0.5.3"
+version = "0.5.4"
 dependencies = [
  "bon",
  "bytes",
···
  "getrandom 0.2.16",
  "http",
  "jacquard-api 0.5.3",
- "jacquard-common 0.5.3",
- "jacquard-derive 0.5.3",
+ "jacquard-common 0.5.4",
+ "jacquard-derive 0.5.4",
  "jacquard-identity 0.5.3",
  "jacquard-oauth",
  "jose-jwk",
···
 dependencies = [
  "bon",
  "bytes",
- "jacquard-common 0.5.3",
- "jacquard-derive 0.5.3",
+ "jacquard-common 0.5.4",
+ "jacquard-derive 0.5.4",
  "miette",
  "serde",
  "thiserror 2.0.17",
···
  "bytes",
  "chrono",
  "jacquard",
- "jacquard-common 0.5.3",
- "jacquard-derive 0.5.3",
+ "jacquard-common 0.5.4",
+ "jacquard-derive 0.5.4",
  "jacquard-identity 0.5.3",
  "k256",
  "miette",
···
 
 [[package]]
 name = "jacquard-common"
-version = "0.5.3"
+version = "0.5.4"
 dependencies = [
  "base64 0.22.1",
  "bon",
···
 
 [[package]]
 name = "jacquard-derive"
-version = "0.5.3"
+version = "0.5.4"
 dependencies = [
- "jacquard-common 0.5.3",
+ "jacquard-common 0.5.4",
  "proc-macro2",
  "quote",
  "serde",
···
  "hickory-resolver",
  "http",
  "jacquard-api 0.5.3",
- "jacquard-common 0.5.3",
+ "jacquard-common 0.5.4",
  "miette",
  "percent-encoding",
  "reqwest",
···
 
 [[package]]
 name = "jacquard-lexicon"
-version = "0.5.3"
+version = "0.5.4"
 dependencies = [
  "async-trait",
  "clap",
···
 
 [[package]]
 name = "jacquard-oauth"
-version = "0.5.3"
+version = "0.5.4"
 dependencies = [
  "base64 0.22.1",
  "bytes",
···
  "dashmap",
  "elliptic-curve",
  "http",
- "jacquard-common 0.5.3",
+ "jacquard-common 0.5.4",
  "jacquard-identity 0.5.3",
  "jose-jwa",
  "jose-jwk",

Cargo.toml

···
 
 [workspace.package]
 edition = "2024"
-version = "0.5.3"
+version = "0.5.4"
 authors = ["Orual <[e-mail]>"]
 #repository = "https://github.com/rsform/jacquard"
 repository = "https://tangled.org/@nonbinary.computer/jacquard"

README.md

···
 
 Highlights:
 
+- initial streaming support
 - experimental WASM support
 - better value type deserialization helpers
 - service auth implementation
···
 ```
 
 
-### Streaming Support
+### Initial Streaming Support
 
-Jacquard supports efficient streaming for large payloads:
+Jacquard is building out support for efficient streaming for large payloads:
 
 - **Blob uploads/downloads**: Stream media without loading into memory
 - **CAR file streaming**: Efficient repo sync operations

crates/jacquard-common/Cargo.toml

···
 name = "jacquard-common"
 description = "Core AT Protocol types and utilities for Jacquard"
 edition.workspace = true
-version = "0.5.3"
+version = "0.5.4"
 authors.workspace = true
 repository.workspace = true
 keywords.workspace = true

crates/jacquard-common/src/xrpc.rs

···
     where
         R: XrpcRequest + Send + Sync,
         <R as XrpcRequest>::Response: Send + Sync;
+
+    /// Send an XRPC request and parse the response
+    #[cfg(not(target_arch = "wasm32"))]
+    fn send_with_opts<R>(
+        &self,
+        request: R,
+        opts: CallOptions<'_>,
+    ) -> impl Future<Output = XrpcResult<Response<<R as XrpcRequest>::Response>>>
+    where
+        R: XrpcRequest + Send + Sync,
+        <R as XrpcRequest>::Response: Send + Sync,
+        Self: Sync;
+
+    /// Send an XRPC request and parse the response
+    #[cfg(target_arch = "wasm32")]
+    fn send_with_opts<R>(
+        &self,
+        request: R,
+        opts: CallOptions<'_>,
+    ) -> impl Future<Output = XrpcResult<Response<<R as XrpcRequest>::Response>>>
+    where
+        R: XrpcRequest + Send + Sync,
+        <R as XrpcRequest>::Response: Send + Sync;
 }
 
 /// Stateless XRPC call builder.

crates/jacquard-oauth/Cargo.toml

···
 [package]
 name = "jacquard-oauth"
-version = "0.5.3"
+version = "0.5.4"
 edition.workspace = true
 description = "AT Protocol OAuth 2.1 core types and helpers for Jacquard"
 authors.workspace = true

crates/jacquard-oauth/src/client.rs

···
 
     async fn send<R>(&self, request: R) -> XrpcResult<Response<<R as XrpcRequest>::Response>>
     where
-        R: XrpcRequest,
+        R: XrpcRequest + Send + Sync,
+        <R as XrpcRequest>::Response: Send + Sync,
+    {
+        let opts = self.options.read().await.clone();
+        self.send_with_opts(request, opts).await
+    }
+
+    async fn send_with_opts<R>(
+        &self,
+        request: R,
+        mut opts: CallOptions<'_>,
+    ) -> XrpcResult<Response<<R as XrpcRequest>::Response>>
+    where
+        R: XrpcRequest + Send + Sync,
+        <R as XrpcRequest>::Response: Send + Sync,
     {
         let base_uri = self.base_uri();
-        let mut opts = self.options.read().await.clone();
         opts.auth = Some(self.access_token().await);
         let guard = self.data.read().await;
         let mut dpop = guard.dpop_data.clone();

crates/jacquard/src/client.rs

···
     repo::{
         create_record::CreateRecordOutput, delete_record::DeleteRecordOutput,
         get_record::GetRecordResponse, put_record::PutRecordOutput,
-        upload_blob::UploadBlobResponse,
     },
     server::{create_session::CreateSessionOutput, refresh_session::RefreshSessionOutput},
 };
···
             let request = UploadBlob::new().body(bytes).build();
 
             // Override Content-Type header with actual mime type instead of */*
-            let base = self.base_uri();
             let mut opts = self.opts().await;
+
             opts.extra_headers.push((
                 CONTENT_TYPE,
                 http::HeaderValue::from_str(mime_type.as_str()).map_err(|e| {
···
                     }
                 })?,
             ));
-
-            let response: Response<UploadBlobResponse> = {
-                let http_request =
-                    xrpc::build_http_request(&base, &request, &opts).map_err(|e| {
-                        AgentError::Client(ClientError::Transport(TransportError::from(e)))
-                    })?;
-
-                let http_response = self.send_http(http_request).await.map_err(|e| {
-                    AgentError::Client(ClientError::Transport(TransportError::Other(Box::new(e))))
-                })?;
-
-                xrpc::process_response(http_response)
-            }?;
-
+            let response = self.send_with_opts(request, opts).await?;
             let output = response.into_output().map_err(|e| match e {
                 XrpcError::Auth(auth) => AgentError::Auth(auth),
                 XrpcError::Generic(g) => AgentError::Generic(g),
···
         <R as XrpcRequest>::Response: Send + Sync,
     {
         async move { self.inner.send(request).await }
+    }
+
+    async fn send_with_opts<R>(
+        &self,
+        request: R,
+        opts: CallOptions<'_>,
+    ) -> XrpcResult<Response<<R as XrpcRequest>::Response>>
+    where
+        R: XrpcRequest + Send + Sync,
+        <R as XrpcRequest>::Response: Send + Sync,
+    {
+        self.inner.send_with_opts(request, opts).await
     }
 }
 

crates/jacquard/src/client/credential_session.rs

···
         R: XrpcRequest + Send + Sync,
         <R as XrpcRequest>::Response: Send + Sync,
     {
+        let opts = self.options.read().await.clone();
+        self.send_with_opts(request, opts).await
+    }
+
+    async fn send_with_opts<R>(
+        &self,
+        request: R,
+        mut opts: CallOptions<'_>,
+    ) -> XrpcResult<Response<<R as XrpcRequest>::Response>>
+    where
+        R: XrpcRequest + Send + Sync,
+        <R as XrpcRequest>::Response: Send + Sync,
+    {
         let base_uri = self.base_uri();
         let auth = self.access_token().await;
-        let mut opts = self.options.read().await.clone();
         opts.auth = auth;
         let resp = self
             .client