rightkit-http

Shared blocking HTTP client for Right Suite applications. It provides timeouts, bounded bodies, retry and backoff that honours Retry-After (never retrying unsafe methods), streaming responses, WHATWG Server-Sent Events decoding, redacted secrets, and tamper-evident wrapping of untrusted web text before it reaches a model.

Catalog capability: http-client. Published to crates.io (see INDEX.md).

What it owns

• Client, ClientConfig, Request, Response, StreamResponse: timeouts, bounded bodies, redirect policy, streaming reads, and get_json.
• RetryPolicy: retry and backoff. Retries respect Retry-After. Non-idempotent methods are not retried.
• sse: SseDecoder, SseReader, SseEvent. WHATWG-compliant Server-Sent Events.
• untrusted: wrap_untrusted_web_text for external text, with boundary markers and injection-signal reporting.
• secret: a redacted Secret, and the SecretStore trait that rightkit-secrets implements. MemorySecretStore is provided for tests.
• testing (feature): an in-process mock server that records exact requests.

When to use it

• Use it for blocking HTTP calls from Right Suite apps where timeouts, retries and bounded bodies must be consistent.
• Use it for SSE streams and for wrapping web text before model input.

Do not use it for async code. The client is blocking. It is built on ureq with rustls.

Cargo features

To opt out of gzip:

rightkit-http = { version = "<exact published version from INDEX.md>", default-features = false }

Usage

Client configuration, from the crate README. Every field below exists in ClientConfig:

use std::time::Duration;
use rightkit_http::{Client, ClientConfig, RetryPolicy};

let client = Client::new(ClientConfig {
    connect_timeout: Some(Duration::from_millis(500)),
    response_timeout: Some(Duration::from_millis(500)),
    recv_body_timeout: Some(Duration::from_secs(3)),
    request_timeout: Duration::from_secs(5),
    max_redirects: 10,
    max_redirects_will_error: true,
    retry: RetryPolicy::none(),
    ..ClientConfig::default()
});

Request shape, from tests/e2e.rs: Request::post(url).bearer(token).json(&value)? then client.send(&req)?.

Timeouts

• connect_timeout and response_timeout are Option<Duration>. The defaults are Some(10 s) for connect and Some(60 s) for response headers. Use None to disable a per-phase deadline. Disabling phase deadlines does not disable global deadlines.
• Buffered calls use request_timeout (60 s by default). Streams use stream_timeout (None by default).
• recv_body_timeout defaults to None. When set, it limits total body-receive time after headers arrive. Progress does not reset it.
• Buffered body timeouts return HttpError::Timeout. Stream readers keep the underlying std::io::Error. Body reads are never retried.
• Callers that passed bare durations to connect_timeout or response_timeout must wrap them in Some(...). The change is recorded in CHANGELOG.md.

Redirects

• max_redirects defaults to 0, so redirects are not followed. With 0, a 3xx response is always returned, whatever the error policy.
• max_redirects_will_error defaults to true, matching ureq. When a nonzero limit is exhausted, the call returns HttpError::Transport { connect_phase: false, .. }. That error is eligible for idempotent retries under the retry policy.
• Set it to false to receive the final 3xx through send_any.

Platform support

Pure Rust over ureq with rustls. No platform-specific code in the crate. Certificate and TLS behaviour follows rustls.

Tests

tests/e2e.rs: a real local TCP server. Assertions use exact requests seen on the wire and exact bytes received.

Version and changes

Published version: see INDEX.md. Version history: CHANGELOG.md.