Struct ClientConfig 

pub struct ClientConfig {

    pub user_agent: String,
    pub connect_timeout: Option<Duration>,
    pub request_timeout: Duration,
    pub response_timeout: Option<Duration>,
    pub recv_body_timeout: Option<Duration>,
    pub stream_timeout: Option<Duration>,
    pub idle_timeout: Option<Duration>,
    pub max_redirects: u32,
    pub max_redirects_will_error: bool,
    pub max_response_bytes: usize,
    pub retry: RetryPolicy,
    pub on_retry: Option<Arc<dyn Fn(&RetryEvent) + Send + Sync>>,
    pub on_attempt: Option<Arc<dyn Fn(&AttemptEvent) -> Result<(), String> + Send + Sync>>,
    pub redact_values: Vec<String>,
    pub address_policy: AddressPolicy,
    pub proxy: ProxyMode,
    pub proxy_bypass_first_party: bool,
    pub trust: TrustRoots,
    pub https_only: bool,
}

Fields

user_agent: String

connect_timeout: Option<Duration>

Connection-phase deadline; None disables this per-phase deadline.

request_timeout: Duration

Whole-request deadline for buffered calls (headers + body).

response_timeout: Option<Duration>

Time to receive response headers; for streams this is the first-byte (first-token) deadline. None disables this per-phase deadline.

recv_body_timeout: Option<Duration>

Total time to receive the body, starting after response headers arrive. The budget is not restarted per read. None disables this phase deadline.

stream_timeout: Option<Duration>

Optional total lifetime cap for a stream body.

idle_timeout: Option<Duration>

Idle (stall) limit for streamed bodies (Client::stream, Client::stream_any): a read that receives no bytes for this long fails with an io::ErrorKind::TimedOut error, whatever the header, recv_body_timeout and stream_timeout budgets say. The clock restarts on every chunk, so a slow but steady multi-gigabyte download survives. None (default) disables it. The blocking client costs one helper thread per stream while set; the async client’s stream costs one timer. Buffered calls (send) are not affected; use recv_body_timeout there. Applies to the streamed body of both clients.

max_redirects: u32

Redirects followed (0 = never; credentials are never replayed to a new host).

max_redirects_will_error: bool

Error when a nonzero redirect limit is exceeded (default true, like ureq). False returns the final 3xx response. With max_redirects = 0, redirects are never followed and the 3xx response is always returned.

max_response_bytes: usize

retry: RetryPolicy

on_retry: Option<Arc<dyn Fn(&RetryEvent) + Send + Sync>>

on_attempt: Option<Arc<dyn Fn(&AttemptEvent) -> Result<(), String> + Send + Sync>>

Hook that runs before every attempt, including the first, beneath the retry loop, so budget and spend gates re-enter on each try (a retry is a new spend). Err(reason) stops the call with HttpError::InvalidRequest("attempt N refused: reason"), which is never retried; nothing is sent for that attempt. It runs on the calling thread (async: on the polling task), so it should not block. None by default.

redact_values: Vec<String>

Secret strings scrubbed from every error message and retry event. Add values with ClientConfig::redact_values.

address_policy: AddressPolicy

Outbound address policy. The default is public-web policy: loopback, private, link-local, CGNAT, multicast and reserved destinations are denied on the first request and on every redirect hop. See crate::netpolicy.

proxy: ProxyMode

Proxy use. The default is ProxyMode::None: no proxy, and environment proxy variables are ignored. See ProxyMode for the threat model.

proxy_bypass_first_party: bool

When the address policy is first-party, connect to the first-party hosts directly even if proxy is set. Default false: first-party calls use the proxy too.

trust: TrustRoots

Certificate roots used to verify servers. The default is TrustRoots::Platform (the OS trust store); TrustRoots::Bundled restores the Mozilla set used before 0.3.0. Verification cannot be disabled.

https_only: bool

Refuse any URL that is not https, on the first request and on every redirect hop, with HttpError::HttpsRequired. Default false, which keeps the earlier behaviour (plain http allowed; an HTTPS to HTTP redirect is still refused by the address policy unless it opts in).

Implementations

impl ClientConfig

pub fn first_party(hosts: Vec<String>) -> Self

Default settings with a first-party policy: only hosts (exact match), only over HTTPS, resolving to public addresses unless the policy opts a host out with AddressPolicy::allow_private_resolution. Use it for license checks and model downloads against known hosts.

pub fn legacy_ureq_parity(user_agent: impl Into<String>) -> Self

Settings that match a plain ureq agent, for callers moving off direct ureq: environment proxy variables honoured (ProxyMode::Environment), Mozilla roots (TrustRoots::Bundled), 10 redirects, no retries (RetryPolicy::none) and the given user agent. Every other field keeps its Default value. It does NOT enable private-address resolution: the address policy stays public-web unless set explicitly.

pub fn on_attempt( self, hook: impl Fn(&AttemptEvent) -> Result<(), String> + Send + Sync + 'static, ) -> Self

Set the per-attempt hook; see ClientConfig::on_attempt.

pub fn address_policy(self, policy: AddressPolicy) -> Self

Replace the outbound address policy.

pub fn proxy(self, mode: ProxyMode) -> Self

Set the proxy mode; see ProxyMode.

pub fn trust(self, trust: TrustRoots) -> Self

Choose the certificate roots; see TrustRoots.

pub fn idle_timeout(self, idle: Option<Duration>) -> Self

Set the idle (no bytes received) limit for streamed bodies; see ClientConfig::idle_timeout.

pub fn https_only(self, https_only: bool) -> Self

Refuse non-https URLs and redirect hops; see ClientConfig::https_only.

pub fn proxy_bypass_first_party(self, bypass: bool) -> Self

Let a first-party client reach its hosts without the proxy; see ClientConfig::proxy_bypass_first_party.

pub fn redact_values(self, values: Vec<String>) -> Self

Add secret strings to scrub from error text ([redacted]). Empty strings are ignored.

Trait Implementations

impl Clone for ClientConfig

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Default for ClientConfig

fn default() -> Self

Returns the “default value” for a type.