gemini_bridge 0.1.14

Types and functions to interact with Gemini AI API
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

use anyhow::Error;
use async_trait::async_trait;
use serde_json::json;

use super::{request::RequestBody, response::GenerateContentResponse};

fn build_generate_content_uri(api_key: String, model: String) -> String {
    let result = format!(
        "https://generativelanguage.googleapis.com/v1beta/models/{}:generateContent?key={}",
        model, api_key
    );
    return result;
}

// fn build_generate_stream_uri(api_key: String, model: String) -> String {
//     let result = format!(
//         "https://generativelanguage.googleapis.com/v1beta/models/{}:streamGenerateContent?alt=sse&key={}",
//         model, api_key
//     );
//     return result;
// }

#[async_trait]
pub trait TextGenerator: Send + Sync {
    async fn generate_content(&self, req: RequestBody) -> Result<GenerateContentResponse, Error>;
    // async fn generate_content_stream(
    //     &self,
    //     req: RequestBody,
    // ) -> Result<GenerateContentResponse, Error>;
}

pub(crate) struct TextGeneratorImpl {
    pub api_key: String,
    pub model: String,
}

#[async_trait]
impl TextGenerator for TextGeneratorImpl {
    async fn generate_content(&self, req: RequestBody) -> Result<GenerateContentResponse, Error> {
        let uri = &build_generate_content_uri(self.api_key.to_owned(), self.model.to_owned());

        let request_body = json!(req);

        let res = reqwest::Client::new()
            .post(uri)
            .json(&request_body)
            .send()
            .await;

        print!("uri: {}", uri);

        let response_body = match res {
            Ok(response) => {
                if response.status().is_success() {
                    response.text().await?
                } else {
                    return Err(Error::msg(format!(
                        "Request failed with status: {}",
                        response.status()
                    )));
                }
            }
            Err(e) => return Err(Error::new(e)),
        };

        let result: GenerateContentResponse = match serde_json::from_str(&response_body) {
            Ok(parsed) => parsed,
            Err(e) => return Err(Error::new(e)),
        };

        Ok(result)
    }

    // async fn generate_content_stream(
    //     &self,
    //     req: RequestBody,
    // ) -> Result<GenerateContentResponse, Error> {
    //     let uri = &build_generate_stream_uri(self.api_key.to_owned(), self.model.to_owned());

    //     let request_body = json!(req);

    //     let res = reqwest::Client::new()
    //         .post(uri)
    //         .json(&request_body)
    //         .send()
    //         .await;

    //     print!("uri: {}", uri);

    //     let response_body = match res {
    //         Ok(response) => {
    //             if response.status().is_success() {
    //                 response.text().await?
    //             } else {
    //                 return Err(Error::msg(format!(
    //                     "Request failed with status: {}",
    //                     response.status()
    //                 )));
    //             }
    //         }
    //         Err(e) => return Err(Error::new(e)),
    //     };

    //     let result: GenerateContentResponse = match serde_json::from_str(&response_body) {
    //         Ok(parsed) => parsed,
    //         Err(e) => return Err(Error::new(e)),
    //     };

    //     Ok(result)
    // }
}