Struct HttpRequest 

#[non_exhaustive]
pub struct HttpRequest {
    pub method: Method,
    pub url: String,
    pub headers: Headers,
    pub body: Option<Bytes>,
    pub timeout: Option<Duration>,
}

An HTTP request built by a provider.

Debug output redacts credential headers (see Headers).

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

method: Method

Method.

url: String

Absolute URL.

headers: Headers

Headers, in order.

body: Option<Bytes>

Body, if any.

timeout: Option<Duration>

Bound on the whole exchange, when the provider sets one. Streaming requests usually leave it unset.

Implementations

impl HttpRequest

pub fn get(url: impl Into<String>) -> Self

A GET request.

pub fn post(url: impl Into<String>, body: impl Into<Bytes>) -> Self

A POST request with body.

pub fn header(self, name: impl Into<String>, value: impl Into<String>) -> Self

Add a header.

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

Set (or clear) the timeout.

pub fn body_text(&self) -> Option<&str>

The body as UTF-8 text, if it is valid UTF-8.

pub fn sensitive_header( self, name: impl Into<String>, value: impl Into<String>, ) -> Self

Add a header whose value is a secret: Debug output redacts it whatever its name. For an adapter that places a credential itself (CredentialPlacement::Custom).

pub fn with_headers(self, headers: &Headers) -> Self

Set each of headers, replacing the request’s headers of the same name (ignoring case) and adding the others, in order. For the headers a provider sends with every request: the bundled providers set their DEFAULT_USER_AGENT and the builder’s own headers (header(name, value), validated by config::static_headers) with it, after their protocol headers and before apply_options, so a request’s own headers still win.

use allama_http::{Headers, HttpRequest};

let defaults: Headers = [("user-agent", "my-app/1.0"), ("x-route", "eu")].into_iter().collect();
let request = HttpRequest::post("https://api.example.com/v1/chat", "{}")
    .header("User-Agent", "allama/0.1.0")
    .with_headers(&defaults);
assert_eq!(request.headers.get("user-agent"), Some("my-app/1.0"));
assert_eq!(request.headers.iter().count(), 2);

pub fn apply_options( self, options: &RequestOptions, slot: &CredentialSlot, ) -> Result<Self>

Apply the caller’s transport options for this request: the HttpRequestOptions in options, typed or in their JSON form, with the credentials addressed to slot’s scope.

Call it once the request carries every header the adapter sets, including its configured credential, and before sending it. Every bundled HTTP adapter calls it with the options of the request it serves and its own CredentialSlot, so callers get the same behaviour from first- and third-party adapters. In order, it:

1. refuses, before anything is sent, a plain header that would carry a credential (see Errors);
2. replaces the request’s headers with the plain headers of the same name, and adds the others;
3. places the Credential::api_key addressed to the slot’s scope as the slot’s placement says, removing the configured credential and every header the slot replaces. A Custom slot is left alone: the adapter signs or places its credential after this call;
4. adds the Credential::header values addressed to the scope, each replacing the headers of the same name.

Credentials addressed to other scopes are never sent. Placed credentials are redacted from Debug whatever the header name.

use allama::ChatRequest;
use allama_http::{Credential, CredentialPlacement, CredentialSlot, HttpRequest, HttpRequestOptions};

let slot = CredentialSlot::new("anthropic", CredentialPlacement::Header("x-api-key".into()));
let request = ChatRequest::new("m").user("Hi").with_option(
    HttpRequestOptions::new()
        .credential("anthropic", Credential::api_key("tenant-key"))
        .credential("openai", Credential::api_key("other-account"))
        .header("x-tenant-id", "acme"),
);
let http = HttpRequest::post("https://api.example.com/v1/messages", "{}")
    .header("x-api-key", "provider-key")
    .apply_options(&request.options, &slot)?;
assert_eq!(http.headers.get("x-api-key"), Some("tenant-key"));
assert_eq!(http.headers.get("x-tenant-id"), Some("acme"));
assert!(!format!("{http:?}").contains("other-account"));

Errors

• allama::Error::InvalidRequest when the JSON form of the options is malformed, names a header on the exact credential list (is_credential_header), or sets credentials.
• An authored allama::Error::Configuration, before anything is sent, when a plain header is named on the exact credential list (is_credential_header) or is one the slot writes or replaces, or when the slot is required and no credential is addressed to its scope. These are the application’s bugs, not the end user’s, so they are not retried, never fall over to another provider, and map to a server error. Error text names headers and scopes, never secrets.

Trait Implementations

impl Clone for HttpRequest

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for HttpRequest

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for HttpRequest

impl PartialEq for HttpRequest

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for HttpRequest