1use std::fmt;
11use std::str::FromStr;
12
13use serde::{Deserialize, Serialize};
14
15#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
19#[serde(rename_all = "camelCase")]
20pub struct GenerationConfig {
21 #[serde(skip_serializing_if = "Option::is_none")]
26 pub response_modalities: Option<Vec<Modality>>,
27 #[serde(skip_serializing_if = "Option::is_none")]
28 pub speech_config: Option<SpeechConfig>,
29 #[serde(skip_serializing_if = "Option::is_none")]
30 pub thinking_config: Option<ThinkingConfig>,
31 #[serde(skip_serializing_if = "Option::is_none")]
33 pub media_resolution: Option<MediaResolution>,
34 #[serde(skip_serializing_if = "Option::is_none")]
35 pub temperature: Option<f32>,
36 #[serde(skip_serializing_if = "Option::is_none")]
37 pub top_p: Option<f32>,
38 #[serde(skip_serializing_if = "Option::is_none")]
39 pub top_k: Option<u32>,
40 #[serde(skip_serializing_if = "Option::is_none")]
41 pub max_output_tokens: Option<u32>,
42 #[serde(skip_serializing_if = "Option::is_none")]
43 pub candidate_count: Option<u32>,
44}
45
46#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
48#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
49pub enum Modality {
50 Audio,
51 Text,
52}
53
54#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
57#[serde(rename_all = "camelCase")]
58pub struct SpeechConfig {
59 pub voice_config: VoiceConfig,
60}
61
62#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
63#[serde(rename_all = "camelCase")]
64pub struct VoiceConfig {
65 pub prebuilt_voice_config: PrebuiltVoiceConfig,
66}
67
68#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
69#[serde(rename_all = "camelCase")]
70pub struct PrebuiltVoiceConfig {
71 pub voice_name: String,
73}
74
75#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
83#[serde(rename_all = "camelCase")]
84pub struct ThinkingConfig {
85 #[serde(skip_serializing_if = "Option::is_none")]
87 pub thinking_level: Option<ThinkingLevel>,
88 #[serde(skip_serializing_if = "Option::is_none")]
90 pub thinking_budget: Option<u32>,
91 #[serde(skip_serializing_if = "Option::is_none")]
92 pub include_thoughts: Option<bool>,
93}
94
95#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
96#[serde(rename_all = "lowercase")]
97pub enum ThinkingLevel {
98 Minimal,
99 Low,
100 Medium,
101 High,
102}
103
104impl ThinkingLevel {
105 pub const fn as_str(self) -> &'static str {
106 match self {
107 Self::Minimal => "minimal",
108 Self::Low => "low",
109 Self::Medium => "medium",
110 Self::High => "high",
111 }
112 }
113}
114
115impl fmt::Display for ThinkingLevel {
116 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
117 f.write_str(self.as_str())
118 }
119}
120
121#[derive(Debug, Clone, PartialEq, Eq)]
122pub struct ParseThinkingLevelError {
123 raw: String,
124}
125
126impl ParseThinkingLevelError {
127 pub fn raw(&self) -> &str {
128 &self.raw
129 }
130}
131
132impl fmt::Display for ParseThinkingLevelError {
133 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
134 write!(
135 f,
136 "unsupported thinking level {:?}; expected one of: minimal, low, medium, high",
137 self.raw
138 )
139 }
140}
141
142impl std::error::Error for ParseThinkingLevelError {}
143
144impl FromStr for ThinkingLevel {
145 type Err = ParseThinkingLevelError;
146
147 fn from_str(raw: &str) -> Result<Self, Self::Err> {
148 match raw.trim().to_ascii_lowercase().as_str() {
149 "minimal" => Ok(Self::Minimal),
150 "low" => Ok(Self::Low),
151 "medium" => Ok(Self::Medium),
152 "high" => Ok(Self::High),
153 _ => Err(ParseThinkingLevelError {
154 raw: raw.to_string(),
155 }),
156 }
157 }
158}
159
160#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
163#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
164pub enum MediaResolution {
165 MediaResolutionLow,
166 MediaResolutionHigh,
167}
168
169#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
173#[serde(rename_all = "camelCase")]
174pub struct RealtimeInputConfig {
175 #[serde(skip_serializing_if = "Option::is_none")]
176 pub automatic_activity_detection: Option<AutomaticActivityDetection>,
177 #[serde(skip_serializing_if = "Option::is_none")]
179 pub activity_handling: Option<ActivityHandling>,
180 #[serde(skip_serializing_if = "Option::is_none")]
182 pub turn_coverage: Option<TurnCoverage>,
183}
184
185#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
190#[serde(rename_all = "camelCase")]
191pub struct AutomaticActivityDetection {
192 #[serde(skip_serializing_if = "Option::is_none")]
193 pub disabled: Option<bool>,
194 #[serde(skip_serializing_if = "Option::is_none")]
195 pub start_of_speech_sensitivity: Option<StartSensitivity>,
196 #[serde(skip_serializing_if = "Option::is_none")]
198 pub prefix_padding_ms: Option<u32>,
199 #[serde(skip_serializing_if = "Option::is_none")]
200 pub end_of_speech_sensitivity: Option<EndSensitivity>,
201 #[serde(skip_serializing_if = "Option::is_none")]
203 pub silence_duration_ms: Option<u32>,
204}
205
206#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
207#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
208pub enum StartSensitivity {
209 StartSensitivityHigh,
210 StartSensitivityLow,
211}
212
213#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
214#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
215pub enum EndSensitivity {
216 EndSensitivityHigh,
217 EndSensitivityLow,
218}
219
220#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
223#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
224pub enum ActivityHandling {
225 StartOfActivityInterrupts,
227 NoInterruption,
229}
230
231#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
233#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
234pub enum TurnCoverage {
235 TurnIncludesOnlyActivity,
237 TurnIncludesAllInput,
239 TurnIncludesAudioActivityAndAllVideo,
241}
242
243#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
251#[serde(rename_all = "camelCase")]
252pub struct SessionResumptionConfig {
253 #[serde(skip_serializing_if = "Option::is_none")]
254 pub handle: Option<String>,
255}
256
257#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
268#[serde(rename_all = "camelCase")]
269pub struct ContextWindowCompressionConfig {
270 #[serde(skip_serializing_if = "Option::is_none")]
271 pub sliding_window: Option<SlidingWindow>,
272 #[serde(skip_serializing_if = "Option::is_none")]
274 pub trigger_tokens: Option<u64>,
275}
276
277#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
278#[serde(rename_all = "camelCase")]
279pub struct SlidingWindow {
280 #[serde(skip_serializing_if = "Option::is_none")]
281 pub target_tokens: Option<u64>,
282}
283
284#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
292pub struct AudioTranscriptionConfig {}
293
294#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
301#[serde(rename_all = "camelCase")]
302pub struct ProactivityConfig {
303 #[serde(skip_serializing_if = "Option::is_none")]
304 pub proactive_audio: Option<bool>,
305}
306
307#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
315#[serde(rename_all = "camelCase")]
316pub struct HistoryConfig {
317 #[serde(skip_serializing_if = "Option::is_none")]
318 pub initial_history_in_client_content: Option<bool>,
319}
320
321#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
332pub enum Tool {
333 #[serde(rename = "functionDeclarations")]
335 FunctionDeclarations(Vec<FunctionDeclaration>),
336 #[serde(rename = "googleSearch")]
338 GoogleSearch(GoogleSearchTool),
339}
340
341#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
346pub struct GoogleSearchTool {}
347
348#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
353#[serde(rename_all = "camelCase")]
354pub struct FunctionDeclaration {
355 pub name: String,
356 pub description: String,
357 pub parameters: serde_json::Value,
359 #[serde(skip_serializing_if = "Option::is_none")]
366 pub scheduling: Option<FunctionScheduling>,
367 #[serde(skip_serializing_if = "Option::is_none")]
369 pub behavior: Option<FunctionBehavior>,
370}
371
372#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
376#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
377pub enum FunctionScheduling {
378 Interrupt,
380 WhenIdle,
382 Silent,
384}
385
386#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
388#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
389pub enum FunctionBehavior {
390 NonBlocking,
392}