Skip to main content

gproxy_protocol/protocol/gemini/common/
content.rs

1use std::collections::BTreeMap;
2
3use serde::{Deserialize, Serialize};
4
5use super::{
6    CodeExecutionOutcome, ContentRole, ExecutableCodeLanguage, ExtraFields,
7    FunctionResponseScheduling, JsonMap, MediaResolutionLevel, ServerToolType,
8};
9
10#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
11#[serde(rename_all = "camelCase")]
12#[derive(gproxy_protocol_macros::WireBuilder)]
13#[non_exhaustive]
14pub struct Content {
15    #[serde(default, skip_serializing_if = "Vec::is_empty")]
16    pub parts: Vec<Part>,
17    #[serde(skip_serializing_if = "Option::is_none")]
18    pub role: Option<ContentRole>,
19    #[serde(default, skip_serializing_if = "BTreeMap::is_empty", flatten)]
20    pub extra: ExtraFields,
21}
22
23#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
24#[serde(rename_all = "camelCase")]
25#[derive(gproxy_protocol_macros::WireBuilder)]
26#[non_exhaustive]
27pub struct Part {
28    #[serde(skip_serializing_if = "Option::is_none")]
29    pub thought: Option<bool>,
30    #[serde(skip_serializing_if = "Option::is_none")]
31    pub thought_signature: Option<String>,
32    #[serde(skip_serializing_if = "Option::is_none")]
33    pub part_metadata: Option<JsonMap>,
34    #[serde(skip_serializing_if = "Option::is_none")]
35    pub media_resolution: Option<MediaResolution>,
36    #[serde(flatten, skip_serializing_if = "Option::is_none")]
37    pub data: Option<PartData>,
38    #[serde(flatten, skip_serializing_if = "Option::is_none")]
39    pub metadata: Option<PartMetadata>,
40    #[serde(default, skip_serializing_if = "BTreeMap::is_empty", flatten)]
41    pub extra: ExtraFields,
42}
43
44#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
45#[serde(untagged)]
46#[non_exhaustive]
47pub enum PartData {
48    Text {
49        text: String,
50    },
51    InlineData {
52        #[serde(rename = "inlineData")]
53        inline_data: Blob,
54    },
55    FunctionCall {
56        #[serde(rename = "functionCall")]
57        function_call: FunctionCall,
58    },
59    FunctionResponse {
60        #[serde(rename = "functionResponse")]
61        function_response: FunctionResponse,
62    },
63    FileData {
64        #[serde(rename = "fileData")]
65        file_data: FileData,
66    },
67    ExecutableCode {
68        #[serde(rename = "executableCode")]
69        executable_code: ExecutableCode,
70    },
71    CodeExecutionResult {
72        #[serde(rename = "codeExecutionResult")]
73        code_execution_result: CodeExecutionResult,
74    },
75    ToolCall {
76        #[serde(rename = "toolCall")]
77        tool_call: ToolCall,
78    },
79    ToolResponse {
80        #[serde(rename = "toolResponse")]
81        tool_response: ToolResponse,
82    },
83}
84
85#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
86#[serde(untagged)]
87#[non_exhaustive]
88pub enum PartMetadata {
89    VideoMetadata {
90        #[serde(rename = "videoMetadata")]
91        video_metadata: VideoMetadata,
92    },
93}
94
95#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
96#[serde(rename_all = "camelCase")]
97#[derive(gproxy_protocol_macros::WireBuilder)]
98#[non_exhaustive]
99pub struct Blob {
100    pub mime_type: String,
101    pub data: String,
102    #[serde(default, skip_serializing_if = "BTreeMap::is_empty", flatten)]
103    pub extra: ExtraFields,
104}
105
106#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
107#[serde(rename_all = "camelCase")]
108#[derive(gproxy_protocol_macros::WireBuilder)]
109#[non_exhaustive]
110pub struct FileData {
111    #[serde(skip_serializing_if = "Option::is_none")]
112    pub mime_type: Option<String>,
113    pub file_uri: String,
114    #[serde(default, skip_serializing_if = "BTreeMap::is_empty", flatten)]
115    pub extra: ExtraFields,
116}
117
118#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
119#[serde(rename_all = "camelCase")]
120#[derive(gproxy_protocol_macros::WireBuilder)]
121#[non_exhaustive]
122pub struct FunctionCall {
123    #[serde(skip_serializing_if = "Option::is_none")]
124    pub id: Option<String>,
125    pub name: String,
126    #[serde(skip_serializing_if = "Option::is_none")]
127    pub args: Option<JsonMap>,
128    #[serde(default, skip_serializing_if = "BTreeMap::is_empty", flatten)]
129    pub extra: ExtraFields,
130}
131
132#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
133#[serde(rename_all = "camelCase")]
134#[derive(gproxy_protocol_macros::WireBuilder)]
135#[non_exhaustive]
136pub struct FunctionResponse {
137    #[serde(skip_serializing_if = "Option::is_none")]
138    pub id: Option<String>,
139    pub name: String,
140    pub response: JsonMap,
141    #[serde(default, skip_serializing_if = "Vec::is_empty")]
142    pub parts: Vec<FunctionResponsePart>,
143    #[serde(skip_serializing_if = "Option::is_none")]
144    pub will_continue: Option<bool>,
145    #[serde(skip_serializing_if = "Option::is_none")]
146    pub scheduling: Option<FunctionResponseScheduling>,
147    #[serde(default, skip_serializing_if = "BTreeMap::is_empty", flatten)]
148    pub extra: ExtraFields,
149}
150
151#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
152#[serde(rename_all = "camelCase")]
153#[derive(gproxy_protocol_macros::WireBuilder)]
154#[non_exhaustive]
155pub struct FunctionResponsePart {
156    #[serde(flatten, skip_serializing_if = "Option::is_none")]
157    pub data: Option<FunctionResponsePartData>,
158    #[serde(default, skip_serializing_if = "BTreeMap::is_empty", flatten)]
159    pub extra: ExtraFields,
160}
161
162#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
163#[serde(untagged)]
164#[non_exhaustive]
165pub enum FunctionResponsePartData {
166    InlineData {
167        #[serde(rename = "inlineData")]
168        inline_data: FunctionResponseBlob,
169    },
170}
171
172#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
173#[serde(rename_all = "camelCase")]
174#[derive(gproxy_protocol_macros::WireBuilder)]
175#[non_exhaustive]
176pub struct FunctionResponseBlob {
177    pub mime_type: String,
178    pub data: String,
179    #[serde(default, skip_serializing_if = "BTreeMap::is_empty", flatten)]
180    pub extra: ExtraFields,
181}
182
183#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
184#[serde(rename_all = "camelCase")]
185#[derive(gproxy_protocol_macros::WireBuilder)]
186#[non_exhaustive]
187pub struct ExecutableCode {
188    #[serde(skip_serializing_if = "Option::is_none")]
189    pub id: Option<String>,
190    pub language: ExecutableCodeLanguage,
191    pub code: String,
192    #[serde(default, skip_serializing_if = "BTreeMap::is_empty", flatten)]
193    pub extra: ExtraFields,
194}
195
196#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
197#[serde(rename_all = "camelCase")]
198#[derive(gproxy_protocol_macros::WireBuilder)]
199#[non_exhaustive]
200pub struct CodeExecutionResult {
201    #[serde(skip_serializing_if = "Option::is_none")]
202    pub id: Option<String>,
203    pub outcome: CodeExecutionOutcome,
204    #[serde(skip_serializing_if = "Option::is_none")]
205    pub output: Option<String>,
206    #[serde(default, skip_serializing_if = "BTreeMap::is_empty", flatten)]
207    pub extra: ExtraFields,
208}
209
210#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
211#[serde(rename_all = "camelCase")]
212#[derive(gproxy_protocol_macros::WireBuilder)]
213#[non_exhaustive]
214pub struct ToolCall {
215    #[serde(skip_serializing_if = "Option::is_none")]
216    pub id: Option<String>,
217    pub tool_type: ServerToolType,
218    #[serde(skip_serializing_if = "Option::is_none")]
219    pub args: Option<JsonMap>,
220    #[serde(default, skip_serializing_if = "BTreeMap::is_empty", flatten)]
221    pub extra: ExtraFields,
222}
223
224#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
225#[serde(rename_all = "camelCase")]
226#[derive(gproxy_protocol_macros::WireBuilder)]
227#[non_exhaustive]
228pub struct ToolResponse {
229    #[serde(skip_serializing_if = "Option::is_none")]
230    pub id: Option<String>,
231    pub tool_type: ServerToolType,
232    #[serde(skip_serializing_if = "Option::is_none")]
233    pub response: Option<JsonMap>,
234    #[serde(default, skip_serializing_if = "BTreeMap::is_empty", flatten)]
235    pub extra: ExtraFields,
236}
237
238#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
239#[serde(rename_all = "camelCase")]
240#[derive(gproxy_protocol_macros::WireBuilder)]
241#[non_exhaustive]
242pub struct VideoMetadata {
243    #[serde(skip_serializing_if = "Option::is_none")]
244    pub start_offset: Option<String>,
245    #[serde(skip_serializing_if = "Option::is_none")]
246    pub end_offset: Option<String>,
247    #[serde(skip_serializing_if = "Option::is_none")]
248    pub fps: Option<f64>,
249    #[serde(default, skip_serializing_if = "BTreeMap::is_empty", flatten)]
250    pub extra: ExtraFields,
251}
252
253#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
254#[serde(rename_all = "camelCase")]
255#[derive(gproxy_protocol_macros::WireBuilder)]
256#[non_exhaustive]
257pub struct MediaResolution {
258    #[serde(flatten, skip_serializing_if = "Option::is_none")]
259    pub value: Option<MediaResolutionValue>,
260    #[serde(default, skip_serializing_if = "BTreeMap::is_empty", flatten)]
261    pub extra: ExtraFields,
262}
263
264#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
265#[serde(untagged)]
266#[non_exhaustive]
267pub enum MediaResolutionValue {
268    Level { level: MediaResolutionLevel },
269}