开源AI工具：Rust HTTP客户端

Configure the client builder

use specter::{Client, FingerprintProfile};
use specter::fingerprint::http2::Http2Settings;
use specter::transport::h2::PseudoHeaderOrder;
use std::time::Duration;

let client = Client::builder()
    .fingerprint(FingerprintProfile::Chrome148)
    .prefer_http2(true)          // advertise h2 first and reuse pooled connections
    .timeout(Duration::from_secs(30))
    .http2_settings(Http2Settings::default())
    .pseudo_order(PseudoHeaderOrder::Chrome)
    .h3_upgrade(true)            // cache Alt-Svc upgrades
    .build()?;

• fingerprint(FingerprintProfile::Chrome148) selects profile-derived TLS, HTTP/2, and HTTP/3 behavior for the implemented Chrome 148 milestone. Other versions available: Chrome142 through Chrome147, Firefox stable Firefox133 through Firefox151, and Firefox ESR FirefoxEsr115, FirefoxEsr128, FirefoxEsr140. Use .user_agent(...), .default_headers(...), or specter::headers::* helpers when you need exact User-Agent or request header presets; .fingerprint(...) does not inject per-request headers by itself.
• prefer_http2(true) keeps HTTP/1.1 available through ALPN but defaults to pooled HTTP/2.
• timeout(...) adds a global request timeout enforced across all transports.
• http2_settings(...) / pseudo_order(...) let you override SETTINGS frames and pseudo header ordering when you need to mimic a different browser or experiment with fingerprints.
• h3_upgrade(false) disables Alt-Svc based HTTP/3 upgrades if you want deterministic TCP-only behavior.

Install pre-commit (if not installed)

brew install pre-commit # or: pip install pre-commit

Install hooks in this repo

pre-commit install

After installation, `cargo fmt` and `cargo clippy` will run automatically on each commit. To run manually:

Usage

Local native HTTP/3 vs Rust H3 clients

Specter's native HTTP/3 path also has a local same-fixture comparator matrix against quiche, tokio-quiche, h3-quinn, and reqwest HTTP/3. The n=100 artifact 2026-05-25-rfc9220-suite-n100.json passes the H3 superiority gate with all required comparator rows present:

That gate is explicitly for HTTP/3 request/response workloads. quinn_transport and s2n_quic_transport are separate QUIC transport-only evidence, not H3 HTTP comparator rows. Native QUIC recovery, fallback, browser ACK parity, capture presets, and capacity-policy hardening are tracked as closed regression guards in docs/specter-native-h3-remaining-seams.md.

Local RFC 9220 WebSocket-over-H3 tunnel suite vs quiche / tokio-quiche

The same matrix now persists a dedicated rfc9220_full_suite_superiority_gate against low-level quiche and tokio-quiche raw byte tunnels. The n=100 artifact 2026-05-25-rfc9220-suite-n100.json passes that gate (specter_native_rfc9220_tunnel_suite_is_faster_than_required_rfc9220_tunnel_competitors) at 1 KiB payloads:

h3-quinn, reqwest_h3, tokio-tungstenite, and reqwest remain explicit unsupported_by_client capability rows because none expose an RFC 9220 Extended CONNECT raw byte tunnel API. Specter adapters reuse one client across samples; low-level comparators open a fresh QUIC connection per sample.

Local WebSocket echo vs fastwebsockets and tokio-tungstenite

Specter also ships a local RFC 6455 echo benchmark, benches/websocket_vs_fastwebsockets.rs, against fastwebsockets 0.10.0 and tokio-tungstenite 0.24.

From docs/benchmarks/websocket-vs-fastwebsockets/2026-05-24-final.json, using 5,000 measured 1 KiB binary echoes after 500 warmups:

The gate requires Specter to match or exceed both baselines; this run passed at +11.79% vs fastwebsockets and +1.10% vs tokio-tungstenite. Run with cargo bench --bench websocket_vs_fastwebsockets -- --messages 5000 --warmups 500 --payload-bytes 1024 --require-thresholds.

Live LLM streaming vs reqwest

The localhost results above hold up against a real production LLM endpoint. Specter ships a second bench, benches/codex_real_streaming.rs, that hits POST https://chatgpt.com/backend-api/codex/responses (the Codex backend, SSE over HTTP/2) and measures TTFT and end-to-end wall time for both Specter and reqwest with paired interleaved samples.

Specter vs reqwest on POST https://chatgpt.com/backend-api/codex/responses (n=10, 5 pairs):

Both clients negotiated HTTP/2; all 10 samples passed the per-pair oracle (status_code==200 AND delta_count>=1 AND response.completed). All 5 paired samples showed Specter faster, with the wall-time 95% CI excluding zero — a real, measurable Specter advantage on a live LLM stream over the public internet, not just localhost fixtures.

Run with cargo bench --bench codex_real_streaming (skips with exit 0 when ~/.codex/auth.json is absent).

Live LLM WebSocket streaming vs tokio-tungstenite

reqwest doesn't natively support WebSockets, so the receive-side comparison is against tokio-tungstenite 0.24 — the canonical Rust WebSocket client. The companion bench benches/codex_ws_streaming.rs hits the same Codex backend over wss:// and sends a response.create frame, then measures TTFT and wall time over the text-frame stream.

Specter vs tokio-tungstenite 0.24 on wss://chatgpt.com/backend-api/codex/responses (n=50, 25 paired samples):

The story isn't median — it's the tail. tokio-tungstenite has dramatically worse worst-case behavior on this endpoint: p95 TTFT is 2.9× higher and p95 wall time is 1.6× higher. For LLM-streaming applications where one slow request blocks the whole pipeline, this tail behavior matters more than median.

Optimizations applied to win the tail/local echo gate: pre-allocated 16 KB read buffer on WebSocket::new, reused frame encode buffer, CSPRNG-backed mask key cache (one getrandom syscall per 64 outbound frames instead of per-frame), word-sized payload masking, and #[inline] on the frame decode hot path. Source: src/websocket/frame.rs, src/websocket/connection.rs.

The RFC 6455 API exposes both message-level and frame-level control: WebSocket::split() returns independent WebSocketReader / WebSocketWriter halves, next_frame() exposes raw frame boundaries for callers that need fragmentation visibility, and PreparedMessage with send_prepared / send_prepared_batch supports reusable text/binary payloads with fresh client masks per send.

Run with cargo bench --bench codex_ws_streaming.