rust-genai 0.3.1

Rust SDK for the Google Gemini API and Vertex AI
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
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

use crate::client::{
    ApiClient, Backend, ClientConfig, ClientInner, Credentials, HttpOptions, VertexConfig,
};
use rust_genai_types::http::HttpRetryOptions;
use std::sync::Mutex;

static ENV_LOCK: Mutex<()> = Mutex::new(());

pub fn with_env(vars: &[(&str, Option<&str>)], f: impl FnOnce()) {
    let _guard = ENV_LOCK.lock().unwrap();
    let backup: Vec<(String, Option<String>)> = vars
        .iter()
        .map(|(key, _)| ((*key).to_string(), std::env::var(key).ok()))
        .collect();
    for (key, value) in vars {
        match value {
            Some(value) => std::env::set_var(key, value),
            None => std::env::remove_var(key),
        }
    }
    f();
    for (key, value) in backup {
        match value {
            Some(value) => std::env::set_var(key, value),
            None => std::env::remove_var(key),
        }
    }
}

pub fn test_client_inner(backend: Backend) -> ClientInner {
    test_client_inner_with_api_key(backend, Some("test-key"))
}

pub fn test_client_inner_with_api_key(backend: Backend, api_key: Option<&str>) -> ClientInner {
    let vertex_config = if backend == Backend::VertexAi {
        Some(VertexConfig {
            project: "proj".to_string(),
            location: "loc".to_string(),
            credentials: None,
        })
    } else {
        None
    };
    let config = ClientConfig {
        api_key: api_key.map(ToString::to_string),
        backend,
        vertex_config,
        http_options: HttpOptions {
            retry_options: Some(HttpRetryOptions {
                attempts: Some(1),
                ..Default::default()
            }),
            ..Default::default()
        },
        credentials: Credentials::ApiKey("test-key".into()),
        auth_scopes: Vec::new(),
    };
    let api_client = ApiClient::new(&config);
    ClientInner {
        http: reqwest::Client::new(),
        config,
        api_client,
        auth_provider: None,
    }
}

pub fn test_client_inner_with_base(
    backend: Backend,
    base_url: &str,
    api_version: &str,
) -> ClientInner {
    let vertex_config = if backend == Backend::VertexAi {
        Some(VertexConfig {
            project: "proj".to_string(),
            location: "loc".to_string(),
            credentials: None,
        })
    } else {
        None
    };
    let http_options = HttpOptions {
        base_url: Some(base_url.to_string()),
        api_version: Some(api_version.to_string()),
        retry_options: Some(HttpRetryOptions {
            attempts: Some(1),
            ..Default::default()
        }),
        ..Default::default()
    };
    let config = ClientConfig {
        api_key: Some("test-key".into()),
        backend,
        vertex_config,
        http_options,
        credentials: Credentials::ApiKey("test-key".into()),
        auth_scopes: Vec::new(),
    };
    let api_client = ApiClient::new(&config);
    ClientInner {
        http: reqwest::Client::new(),
        config,
        api_client,
        auth_provider: None,
    }
}

pub fn test_vertex_inner_missing_config() -> ClientInner {
    let config = ClientConfig {
        api_key: None,
        backend: Backend::VertexAi,
        vertex_config: None,
        http_options: HttpOptions {
            retry_options: Some(HttpRetryOptions {
                attempts: Some(1),
                ..Default::default()
            }),
            ..Default::default()
        },
        credentials: Credentials::ApplicationDefault,
        auth_scopes: Vec::new(),
    };
    let api_client = ApiClient::new(&config);
    ClientInner {
        http: reqwest::Client::new(),
        config,
        api_client,
        auth_provider: None,
    }
}