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