async_llm/
client.rs

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
83
84
85
86
87
88
89
90
91
92
93
use secrecy::SecretString;

use crate::{
    chat::Chat,
    completions::Completions,
    http::{HttpClient, SimpleHttpClient},
    providers::{openai::OpenAIProvider, OpenAIConfig, Provider},
    RawProvider,
};

pub type DefaultHttpClient<C> = SimpleHttpClient<C>;

#[derive(Debug, Clone)]
pub struct Client<P: Provider, H: HttpClient> {
    pub(crate) provider: P,
    pub(crate) http_client: H,
}

impl<P: Provider> Client<P, DefaultHttpClient<P::Config>> {
    pub fn with_provider(provider: P) -> Self {
        let config = provider.config().clone();
        Self {
            provider,
            http_client: DefaultHttpClient::new(config),
        }
    }
}

impl<P: Provider, H: HttpClient> Client<P, H> {
    pub fn with_args(provider: P, http_client: H) -> Self {
        Client {
            provider,
            http_client,
        }
    }

    pub fn provider(&self) -> &P {
        &self.provider
    }

    pub fn http_client(&self) -> &H {
        &self.http_client
    }
}

impl Client<OpenAIProvider, DefaultHttpClient<OpenAIConfig>> {
    pub fn new() -> Self {
        let provider = OpenAIProvider::default();
        let config = provider.config().clone();
        Self {
            provider,
            http_client: DefaultHttpClient::new(config),
        }
    }

    pub fn with_auth(base_url: impl Into<String>, api_key: Option<SecretString>) -> Self {
        let config = OpenAIConfig::new(base_url, api_key);
        let provider = OpenAIProvider::new(config.clone());
        Self {
            provider,
            http_client: DefaultHttpClient::new(config),
        }
    }
}

impl Client<RawProvider, DefaultHttpClient<OpenAIConfig>> {
    pub fn raw() -> Self {
        let provider = RawProvider::default();
        let config = provider.config().clone();
        Self {
            provider,
            http_client: DefaultHttpClient::new(config),
        }
    }

    pub fn with_auth_raw(base_url: impl Into<String>, api_key: Option<SecretString>) -> Self {
        let config = OpenAIConfig::new(base_url, api_key);
        let provider = RawProvider::new(config.clone());
        Self {
            provider,
            http_client: DefaultHttpClient::new(config),
        }
    }
}

impl<P: Provider, H: HttpClient> Client<P, H> {
    pub fn completions(&self) -> Completions<P, H> {
        Completions::new(self)
    }
    pub fn chat(&self) -> Chat<P, H> {
        Chat::new(self)
    }
}