gems 0.1.4

💎 A cli, tui, and sdk for interacting with the Gemini API (WIP)
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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

use serde::{Deserialize, Serialize};

/// Request structure for content generation.
#[derive(Debug, Serialize, Deserialize)]
pub struct GeminiRequest {
    /// The model to be used for content generation.
    pub model: String,

    /// List of content items for generation.
    pub contents: Vec<Content>,

    #[serde(rename = "generationConfig", skip_serializing_if = "Option::is_none")]
    pub config: Option<GenerationConfig>,

    /// Optional system-level instruction.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub system_instruction: Option<Content>,
}

/// Request structure for content embedding.
#[derive(Debug, Serialize, Deserialize)]
pub struct GeminiEmbedRequest {
    /// The model to be used for content embedding.
    pub model: String,

    /// Content item for embedding.
    pub content: Content,
}
/// Request structure for batch content embedding.
#[derive(Debug, Serialize, Deserialize)]
pub struct GeminiEmbedRequests {
    /// List of requests for batch content embedding.
    pub requests: Vec<GeminiEmbedRequest>,
}
/// Structure representing content information.
#[derive(Debug, Serialize, Deserialize)]
pub struct Content {
    /// List of parts composing the content.
    pub parts: Vec<Part>,
}

/// Define an enum to represent different types of parts in the content.
#[derive(Debug, Serialize, Deserialize, Clone)]
#[serde(untagged)]
pub enum Part {
    /// Represents a text part in the content.
    Text { text: String },
    /// Represents an image part in the content.
    Image { inline_data: Option<ImageContent> },
}

/// Implement the `Part` enum for the `Serialize` trait
impl Part {
    /// Create a new `Part` with text content.
    pub fn text(text: &str) -> Self {
        Part::Text {
            text: text.to_string(),
        }
    }

    /// Create a new `Part` with image content.
    pub fn image(inline_data: Option<ImageContent>) -> Self {
        Part::Image { inline_data }
    }
}

/// Structure representing a candidate content.
#[derive(Debug, Deserialize)]
pub struct Candidate {
    /// The content of the candidate.
    pub content: Content,
}

/// Structure representing the image part of the Gemini request.
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct ImageContent {
    /// The MIME type of the image.
    pub mime_type: String,
    /// The actual image data in a base64-encoded string.
    pub data: String,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct GenerationConfig {
    #[serde(rename = "responseModalities")]
    pub response_modalities: Vec<String>,
}

/// Request payload for video generation using Veo.
#[derive(Debug, Serialize)]
pub struct VideoGenRequest {
    pub instances: Vec<VideoPrompt>,
    pub parameters: VideoParameters,
}

/// The prompt inside the request.
#[derive(Debug, Serialize)]
pub struct VideoPrompt {
    pub prompt: String,
}

/// Optional parameters for generation behavior.
#[derive(Debug, Serialize)]
pub struct VideoParameters {
    #[serde(rename = "aspectRatio")]
    pub aspect_ratio: String,

    #[serde(rename = "personGeneration")]
    pub person_generation: String,
}

#[derive(Debug, Serialize)]
pub struct TtsRequest {
    pub model: String,
    pub contents: Vec<Content>,
    #[serde(rename = "generationConfig")]
    pub generation_config: TtsGenerationConfig,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub system_instruction: Option<Content>,
}

#[derive(Debug, Serialize)]
pub struct TtsGenerationConfig {
    #[serde(rename = "responseModalities")]
    pub response_modalities: Vec<String>,
    #[serde(rename = "speechConfig")]
    pub speech_config: SpeechConfig,
}

#[derive(Debug, Serialize)]
pub struct SpeechConfig {
    #[serde(rename = "voiceConfig")]
    pub voice_config: VoiceConfig,
}

#[derive(Debug, Serialize)]
pub struct VoiceConfig {
    #[serde(rename = "prebuiltVoiceConfig")]
    pub prebuilt_voice_config: PrebuiltVoiceConfig,
}

#[derive(Debug, Serialize)]
pub struct PrebuiltVoiceConfig {
    #[serde(rename = "voiceName")]
    pub voice_name: String,
}