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

use std::sync::Arc;

use reqwest::Method;
use url::Url;

use super::wire::AnthropicErrorEnvelope;
use crate::KitError;
use crate::config::TransportConfig;
use crate::config::{AnthropicConfig, DEFAULT_ANTHROPIC_VERSION};
use crate::error::ErrorKind;
use crate::transport::{AuthMode, AuthScheme, CheckedRequestSpec, ProviderHttpContext};

#[derive(Clone)]
pub(crate) struct AnthropicApiContext {
    transport: ProviderHttpContext,
}

pub(super) const ANTHROPIC_REQUESTS: CheckedRequestSpec =
    CheckedRequestSpec::new(AnthropicErrorEnvelope::parse);

impl AnthropicApiContext {
    pub(crate) fn shared(
        config: AnthropicConfig,
        transport: TransportConfig,
    ) -> Result<Arc<Self>, KitError> {
        let transport = ProviderHttpContext::new(
            config.base_url().clone(),
            AuthScheme::Header {
                name: "x-api-key".to_string(),
                value: config.api_key().clone(),
                prefix: None,
            },
            transport,
        )?;

        Ok(Arc::new(Self { transport }))
    }

    pub(super) fn classify_error(kind: &str) -> ErrorKind {
        match kind {
            "invalid_request_error" => ErrorKind::InvalidRequest,
            "authentication_error" => ErrorKind::Authentication,
            "permission_error" => ErrorKind::PermissionDenied,
            "not_found_error" => ErrorKind::NotFound,
            "request_too_large" => ErrorKind::RequestTooLarge,
            "rate_limit_error" => ErrorKind::RateLimited,
            "api_error" => ErrorKind::Internal,
            "billing_error" => ErrorKind::Billing,
            "conflict_error" => ErrorKind::Conflict,
            "timeout_error" => ErrorKind::DeadlineExceeded,
            "overloaded_error" => ErrorKind::ServiceUnavailable,
            _ => ErrorKind::ProviderRejected,
        }
    }

    pub(crate) fn transport(&self) -> &ProviderHttpContext {
        &self.transport
    }

    pub(crate) fn request(
        &self,
        method: Method,
        path: &str,
    ) -> Result<reqwest::RequestBuilder, KitError> {
        Ok(self.decorate_request(self.transport.request(method, path)?))
    }

    pub(crate) fn request_absolute(&self, method: Method, url: Url) -> reqwest::RequestBuilder {
        let auth = if self.transport.is_same_origin(&url) {
            AuthMode::Apply
        } else {
            AuthMode::Skip
        };
        self.decorate_request(self.transport.request_absolute(method, url, auth))
    }

    fn decorate_request(&self, builder: reqwest::RequestBuilder) -> reqwest::RequestBuilder {
        builder.header("anthropic-version", DEFAULT_ANTHROPIC_VERSION)
    }
}