Refactor HTTP client response handling and TLS session caching

- Updated the response handling in `crates/hpx/src/client/http/future.rs` to use `Response::from_client_response` for better clarity and consistency.
- Enhanced the recovery layer in `crates/hpx/src/client/layer/recovery.rs` to improve error handling and response body processing.
- Modified the request construction in `crates/hpx/src/client/request.rs` to support streaming bodies without pre-buffering.
- Improved the response struct in `crates/hpx/src/client/response.rs` to allow for better body handling and deserialization.
- Refactored header sorting logic in `crates/hpx/src/header.rs` to preserve original casing and order while processing headers.
- Enhanced TLS session caching in `crates/hpx/src/tls/boring.rs` and `crates/hpx/src/tls/boring/cache.rs` to support better session management and eviction policies.

Author: Akagi201

Cargo.toml

@@ -3,7 +3,7 @@ members = ["crates/*", "bin/*"]
 resolver = "3"
 
 [workspace.package]
-version = "2.4.7"
+version = "2.4.8"
 edition = "2024"
 authors = ["Akagi201 <akagi201@gmail.com>"]
 license = "Apache-2.0"
@@ -185,11 +185,11 @@ all = "warn"
 
 [workspace.dependencies]
 # local crates
-fastwebsockets = { path = "crates/fastwebsockets", package = "hpx-fastwebsockets", version = "2.4.7" }
-hpx = { path = "crates/hpx", version = "2.4.7" }
-hpx-dl = { path = "crates/hpx-dl", version = "2.4.7" }
-hpx-yawc = { path = "crates/yawc", version = "2.4.7" }
-yawc = { path = "crates/yawc", version = "2.4.7" }
+fastwebsockets = { path = "crates/fastwebsockets", package = "hpx-fastwebsockets", version = "2.4.8" }
+hpx = { path = "crates/hpx", version = "2.4.8" }
+hpx-dl = { path = "crates/hpx-dl", version = "2.4.8" }
+hpx-yawc = { path = "crates/yawc", version = "2.4.8" }
+yawc = { path = "crates/yawc", version = "2.4.8" }
 
 # external crates
 ahash = "0.8.12"
@@ -253,7 +253,7 @@ pkcs8 = "0.11.0-rc.8"
 pretty_env_logger = "0.5.0"
 proptest = "1.6.0"
 quick-xml = "0.39.2"
-rand = "0.10.0"
+rand = "0.10.1"
 rustls = "0.23.37"
 rustls-native-certs = "0.8.3"
 rustls-pemfile = "2.2.0"

README.md

@@ -15,10 +15,10 @@ An ergonomic all-in-one HTTP client for browser emulation with TLS, JA3/JA4, and
 
 | Crate | Version | Description |
 |-------|---------|-------------|
-| [`hpx`](https://crates.io/crates/hpx) | 2.4.7 | High Performance HTTP Client |
-| [`hpx-emulation`](https://crates.io/crates/hpx-emulation) | 2.4.7 | Browser emulation profiles |
-| [`hpx-yawc`](https://crates.io/crates/hpx-yawc) | 2.4.7 | WebSocket library (RFC 6455 + compression) |
-| [`hpx-fastwebsockets`](https://crates.io/crates/hpx-fastwebsockets) | 2.4.7 | Fast minimal WebSocket implementation |
+| [`hpx`](https://crates.io/crates/hpx) | 2.4.8 | High Performance HTTP Client |
+| [`hpx-emulation`](https://crates.io/crates/hpx-emulation) | 2.4.8 | Browser emulation profiles |
+| [`hpx-yawc`](https://crates.io/crates/hpx-yawc) | 2.4.8 | WebSocket library (RFC 6455 + compression) |
+| [`hpx-fastwebsockets`](https://crates.io/crates/hpx-fastwebsockets) | 2.4.8 | Fast minimal WebSocket implementation |
 
 ## Features
 
@@ -64,7 +64,7 @@ Add `hpx` to your `Cargo.toml`:
 
 ```toml
 [dependencies]
-hpx = "2.4.7"
+hpx = "2.4.8"
 ```
 
 The default features include **BoringSSL** TLS, **HTTP/1.1**, and **HTTP/2** support.
@@ -73,8 +73,8 @@ For browser emulation, add the utility crate:
 
 ```toml
 [dependencies]
-hpx = "2.4.7"
-hpx-emulation = "2.4.7"
+hpx = "2.4.8"
+hpx-emulation = "2.4.8"
 ```
 
 ## Feature Flags
@@ -125,7 +125,7 @@ The `ws` feature is an alias for `ws-yawc` (the default WebSocket backend). To u
 
 ```toml
 [dependencies]
-hpx = { version = "2.4.7", features = ["ws-fastwebsockets"] }
+hpx = { version = "2.4.8", features = ["ws-fastwebsockets"] }
 ```
 
 When both `ws-yawc` and `ws-fastwebsockets` are enabled, fastwebsockets takes priority.
@@ -135,37 +135,37 @@ When both `ws-yawc` and `ws-fastwebsockets` are enabled, fastwebsockets takes pr
 **Minimal HTTP client:**
 
 ```toml
-hpx = "2.4.7"  # default: boring + http1 + http2
+hpx = "2.4.8"  # default: boring + http1 + http2
 ```
 
 **JSON API client:**
 
 ```toml
-hpx = { version = "2.4.7", features = ["json", "cookies", "gzip"] }
+hpx = { version = "2.4.8", features = ["json", "cookies", "gzip"] }
 ```
 
 **WebSocket client:**
 
 ```toml
-hpx = { version = "2.4.7", features = ["ws"] }
+hpx = { version = "2.4.8", features = ["ws"] }
 ```
 
 **High-performance trading:**
 
 ```toml
-hpx = { version = "2.4.7", features = ["simd-json", "hickory-dns", "zstd", "ws"] }
+hpx = { version = "2.4.8", features = ["simd-json", "hickory-dns", "zstd", "ws"] }
 ```
 
 **Pure Rust (no C dependencies):**
 
 ```toml
-hpx = { version = "2.4.7", default-features = false, features = ["rustls-tls", "http1", "http2"] }
+hpx = { version = "2.4.8", default-features = false, features = ["rustls-tls", "http1", "http2"] }
 ```
 
 **Full-featured:**
 
 ```toml
-hpx = { version = "2.4.7", features = [
+hpx = { version = "2.4.8", features = [
     "json", "form", "query", "multipart", "stream",
     "cookies", "charset",
     "gzip", "brotli", "zstd", "deflate",
@@ -206,7 +206,7 @@ BoringSSL is the default TLS backend, providing robust support for modern TLS fe
 
 ```toml
 [dependencies]
-hpx = "2.4.7"
+hpx = "2.4.8"
 ```
 
 ### Rustls
@@ -217,7 +217,7 @@ A pure Rust TLS implementation. Useful for environments where C dependencies are
 
 ```toml
 [dependencies]
-hpx = { version = "2.4.7", default-features = false, features = ["rustls-tls", "http1", "http2"] }
+hpx = { version = "2.4.8", default-features = false, features = ["rustls-tls", "http1", "http2"] }
 ```
 
 ## Usage Examples
@@ -269,6 +269,45 @@ async fn main() -> hpx::Result<()> {
 }
 ```
 
+### Streaming / Proxying / Gateway
+
+Requires the `stream` feature. For reverse proxies and API gateways, `hpx` can forward framework-native request bodies without buffering the full payload.
+
+```rust
+use axum::{
+    body::Body as AxumBody,
+    extract::{Request as AxumRequest, State},
+    http::{Response as AxumResponse, StatusCode},
+};
+use hpx::{Body, Client, Request};
+
+async fn proxy(
+    State(client): State<Client>,
+    mut req: AxumRequest<AxumBody>,
+) -> Result<AxumResponse<Body>, StatusCode> {
+    let path_and_query = req
+        .uri()
+        .path_and_query()
+        .map(|value| value.as_str())
+        .unwrap_or("/");
+
+    let upstream_uri = format!("https://upstream.internal{path_and_query}")
+        .parse()
+        .map_err(|_| StatusCode::BAD_REQUEST)?;
+    *req.uri_mut() = upstream_uri;
+
+    let upstream_req = Request::from_http(req);
+    let upstream_res = client
+        .execute(upstream_req)
+        .await
+        .map_err(|_| StatusCode::BAD_GATEWAY)?;
+
+    Ok(http::Response::<Body>::from(upstream_res))
+}
+```
+
+If you need to inspect or transform chunks instead of transparently forwarding them, use `Response::bytes_stream()` or `Response::into_body()`. For Tower-native composition, `Client::into_tower_service()` returns the `tower_compat::HpxService` alias.
+
 ### Browser Emulation
 
 Requires the `hpx-emulation` crate with default features.

crates/hpx/README.md

@@ -42,6 +42,45 @@ async fn main() -> hpx::Result<()> {
 }
 ```
 
+## Streaming / Proxying / Gateway
+
+Requires the `stream` feature. `Request::from_http(...)` lets you forward framework-native request bodies into `hpx` without buffering them first, which is useful in reverse proxies and API gateways.
+
+```rust
+use axum::{
+    body::Body as AxumBody,
+    extract::{Request as AxumRequest, State},
+    http::{Response as AxumResponse, StatusCode},
+};
+use hpx::{Body, Client, Request};
+
+async fn proxy(
+    State(client): State<Client>,
+    mut req: AxumRequest<AxumBody>,
+) -> Result<AxumResponse<Body>, StatusCode> {
+    let path_and_query = req
+        .uri()
+        .path_and_query()
+        .map(|value| value.as_str())
+        .unwrap_or("/");
+
+    let upstream_uri = format!("https://upstream.internal{path_and_query}")
+        .parse()
+        .map_err(|_| StatusCode::BAD_REQUEST)?;
+    *req.uri_mut() = upstream_uri;
+
+    let upstream_req = Request::from_http(req);
+    let upstream_res = client
+        .execute(upstream_req)
+        .await
+        .map_err(|_| StatusCode::BAD_GATEWAY)?;
+
+    Ok(http::Response::<Body>::from(upstream_res))
+}
+```
+
+Use `Response::bytes_stream()` when you need per-chunk inspection, and `Client::into_tower_service()` when you want to compose the client inside a Tower middleware stack via `tower_compat::HpxService`.
+
 ## Cloudflare mTLS
 
 `hpx` can attach a client certificate during the TLS handshake, which is required for Cloudflare Access / Zero Trust deployments protected by mutual TLS.