providers-kit 0.0.2

Portable enum-dispatch Kit over multiple model provider APIs.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

use http::{HeaderMap, HeaderName, HeaderValue};
use secrecy::ExposeSecret;

use crate::KitError;
use crate::config::ApiKey;
use crate::error::ValidationViolation;

#[derive(Clone)]
pub(crate) enum AuthScheme {
    None,
    Bearer(ApiKey),
    Header {
        name: String,
        value: ApiKey,
        prefix: Option<String>,
    },
}

impl AuthScheme {
    pub(crate) fn apply(&self, builder: reqwest::RequestBuilder) -> reqwest::RequestBuilder {
        match self {
            Self::None => builder,
            Self::Bearer(token) => builder.bearer_auth(token.as_secret().expose_secret()),
            Self::Header {
                name,
                value,
                prefix,
            } => {
                let rendered = match prefix {
                    Some(prefix) => format!("{prefix} {}", value.as_secret().expose_secret()),
                    None => value.as_secret().expose_secret().to_string(),
                };
                builder.header(name.as_str(), rendered)
            }
        }
    }

    pub(crate) fn apply_headers(&self, headers: &mut HeaderMap) -> Result<(), KitError> {
        match self {
            Self::None => Ok(()),
            Self::Bearer(token) => insert_header(
                headers,
                "authorization",
                format!("Bearer {}", token.as_secret().expose_secret()),
            ),
            Self::Header {
                name,
                value,
                prefix,
            } => {
                let rendered = match prefix {
                    Some(prefix) => format!("{prefix} {}", value.as_secret().expose_secret()),
                    None => value.as_secret().expose_secret().to_string(),
                };
                insert_header(headers, name, rendered)
            }
        }
    }
}

fn insert_header(headers: &mut HeaderMap, name: &str, value: String) -> Result<(), KitError> {
    let name = HeaderName::try_from(name).map_err(|err| {
        KitError::config(
            ValidationViolation::InvalidFormat {
                field: "authentication.header.name",
                rule: "valid HTTP header name",
            },
            format!("invalid provider authentication header name `{name}`: {err}"),
        )
    })?;
    let value = HeaderValue::from_str(&value).map_err(|err| {
        KitError::config(
            ValidationViolation::InvalidFormat {
                field: "authentication.header.value",
                rule: "valid HTTP header value",
            },
            format!("invalid provider authentication header value for `{name}`: {err}"),
        )
    })?;
    headers.insert(name, value);
    Ok(())
}