1use super::input::{
4 ConversationParam, Input, ReasoningConfig, ResponseInputFile, ResponseInputImage,
5 ResponseInputText, TextConfig, present_nullable, present_optional,
6};
7use super::tools::Tool;
8use crate::Rest;
9use serde::{Deserialize, Serialize};
10use std::collections::BTreeMap;
11
12#[derive(
13 Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
14)]
15#[serde(rename_all = "snake_case")]
16#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
17#[derive(gproxy_protocol_macros::DeclaredFields)]
18#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
19pub struct GenerateContentRequestBody {
20 #[serde(
21 default,
22 deserialize_with = "present_optional",
23 skip_serializing_if = "Option::is_none"
24 )]
25 pub access_programs: Option<AccessPrograms>,
26 #[serde(
27 default,
28 deserialize_with = "present_nullable",
29 skip_serializing_if = "Option::is_none"
30 )]
31 pub multi_agent: Option<Option<super::multi_agent::MultiAgentConfig>>,
32 #[serde(
33 default,
34 deserialize_with = "present_nullable",
35 skip_serializing_if = "Option::is_none"
36 )]
37 pub background: Option<Option<bool>>,
38 #[serde(
39 default,
40 deserialize_with = "present_nullable",
41 skip_serializing_if = "Option::is_none"
42 )]
43 pub context_management: Option<Option<Vec<ContextManagement>>>,
44 #[serde(
45 default,
46 deserialize_with = "present_nullable",
47 skip_serializing_if = "Option::is_none"
48 )]
49 pub conversation: Option<Option<ConversationParam>>,
50 #[serde(
51 default,
52 deserialize_with = "present_nullable",
53 skip_serializing_if = "Option::is_none"
54 )]
55 pub include: Option<Option<Vec<ResponseIncludable>>>,
56 #[serde(
57 default,
58 deserialize_with = "present_optional",
59 skip_serializing_if = "Option::is_none"
60 )]
61 pub input: Option<Input>,
62 #[serde(
63 default,
64 deserialize_with = "present_nullable",
65 skip_serializing_if = "Option::is_none"
66 )]
67 pub instructions: Option<Option<String>>,
68 #[serde(
69 default,
70 deserialize_with = "present_nullable",
71 skip_serializing_if = "Option::is_none"
72 )]
73 pub max_output_tokens: Option<Option<i64>>,
74 #[serde(
75 default,
76 deserialize_with = "present_nullable",
77 skip_serializing_if = "Option::is_none"
78 )]
79 pub max_tool_calls: Option<Option<i64>>,
80 #[serde(
81 default,
82 deserialize_with = "present_nullable",
83 skip_serializing_if = "Option::is_none"
84 )]
85 pub metadata: Option<Option<BTreeMap<String, String>>>,
86 #[serde(
87 default,
88 deserialize_with = "present_optional",
89 skip_serializing_if = "Option::is_none"
90 )]
91 pub model: Option<String>,
92 #[serde(
93 default,
94 deserialize_with = "present_nullable",
95 skip_serializing_if = "Option::is_none"
96 )]
97 pub moderation: Option<Option<ResponseModeration>>,
98 #[serde(
99 default,
100 deserialize_with = "present_nullable",
101 skip_serializing_if = "Option::is_none"
102 )]
103 pub parallel_tool_calls: Option<Option<bool>>,
104 #[serde(
105 default,
106 deserialize_with = "present_nullable",
107 skip_serializing_if = "Option::is_none"
108 )]
109 pub previous_response_id: Option<Option<String>>,
110 #[serde(
111 default,
112 deserialize_with = "present_nullable",
113 skip_serializing_if = "Option::is_none"
114 )]
115 pub prompt: Option<Option<ResponsePrompt>>,
116 #[serde(
117 default,
118 deserialize_with = "present_nullable",
119 skip_serializing_if = "Option::is_none"
120 )]
121 pub prompt_cache_key: Option<Option<String>>,
122 #[serde(
123 default,
124 deserialize_with = "present_optional",
125 skip_serializing_if = "Option::is_none"
126 )]
127 pub prompt_cache_options: Option<PromptCacheOptions>,
128 #[serde(
129 default,
130 deserialize_with = "present_nullable",
131 skip_serializing_if = "Option::is_none"
132 )]
133 pub prompt_cache_retention: Option<Option<PromptCacheRetention>>,
134 #[serde(
135 default,
136 deserialize_with = "present_nullable",
137 skip_serializing_if = "Option::is_none"
138 )]
139 pub reasoning: Option<Option<ReasoningConfig>>,
140 #[serde(
141 default,
142 deserialize_with = "present_nullable",
143 skip_serializing_if = "Option::is_none"
144 )]
145 pub safety_identifier: Option<Option<String>>,
146 #[serde(
147 default,
148 deserialize_with = "present_nullable",
149 skip_serializing_if = "Option::is_none"
150 )]
151 pub service_tier: Option<Option<ServiceTier>>,
152 #[serde(
153 default,
154 deserialize_with = "present_nullable",
155 skip_serializing_if = "Option::is_none"
156 )]
157 pub store: Option<Option<bool>>,
158 #[serde(
159 default,
160 deserialize_with = "present_nullable",
161 skip_serializing_if = "Option::is_none"
162 )]
163 pub stream: Option<Option<bool>>,
164 #[serde(
165 default,
166 deserialize_with = "present_nullable",
167 skip_serializing_if = "Option::is_none"
168 )]
169 pub stream_options: Option<Option<StreamOptions>>,
170 #[serde(
171 default,
172 deserialize_with = "present_nullable",
173 skip_serializing_if = "Option::is_none"
174 )]
175 pub temperature: Option<Option<serde_json::Number>>,
176 #[serde(
177 default,
178 deserialize_with = "present_optional",
179 skip_serializing_if = "Option::is_none"
180 )]
181 pub text: Option<TextConfig>,
182 #[serde(
183 default,
184 deserialize_with = "present_optional",
185 skip_serializing_if = "Option::is_none"
186 )]
187 pub tool_choice: Option<super::input::ToolChoice>,
188 #[serde(
189 default,
190 deserialize_with = "present_optional",
191 skip_serializing_if = "Option::is_none"
192 )]
193 pub tools: Option<Vec<Tool>>,
194 #[serde(
195 default,
196 deserialize_with = "present_nullable",
197 skip_serializing_if = "Option::is_none"
198 )]
199 pub top_logprobs: Option<Option<i64>>,
200 #[serde(
201 default,
202 deserialize_with = "present_nullable",
203 skip_serializing_if = "Option::is_none"
204 )]
205 pub top_p: Option<Option<serde_json::Number>>,
206 #[serde(
207 default,
208 deserialize_with = "present_nullable",
209 skip_serializing_if = "Option::is_none"
210 )]
211 pub truncation: Option<Option<GenerateTruncation>>,
212 #[serde(
213 default,
214 deserialize_with = "present_nullable",
215 skip_serializing_if = "Option::is_none"
216 )]
217 pub user: Option<Option<String>>,
218 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
219 pub rest: Rest,
220}
221
222#[derive(
224 Debug,
225 Clone,
226 PartialEq,
227 Eq,
228 Serialize,
229 Deserialize,
230 gproxy_protocol_macros::WireBuilder,
231 gproxy_protocol_macros::DeclaredFields,
232)]
233#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
234#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
235pub struct AccessPrograms {
236 #[serde(
237 default,
238 deserialize_with = "present_optional",
239 skip_serializing_if = "Option::is_none"
240 )]
241 pub cyber: Option<CyberAccessProgram>,
242 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
243 pub rest: Rest,
244}
245
246#[derive(
247 Debug,
248 Clone,
249 Copy,
250 PartialEq,
251 Eq,
252 Serialize,
253 Deserialize,
254 gproxy_protocol_macros::DeclaredFields,
255)]
256#[serde(rename_all = "snake_case")]
257#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
258#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
259pub enum CyberAccessProgram {
260 Standard,
261 DaybreakBlue,
262 DaybreakRed,
263}
264
265#[derive(
266 Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
267)]
268#[serde(rename_all = "snake_case")]
269#[derive(gproxy_protocol_macros::DeclaredFields)]
270#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
271pub struct ContextManagement {
272 pub r#type: String,
273 #[serde(
274 default,
275 deserialize_with = "present_nullable",
276 skip_serializing_if = "Option::is_none"
277 )]
278 pub compact_threshold: Option<Option<i64>>,
279 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
280 pub rest: Rest,
281}
282#[derive(
283 Debug,
284 Clone,
285 Copy,
286 PartialEq,
287 Eq,
288 Serialize,
289 Deserialize,
290 gproxy_protocol_macros::DeclaredFields,
291)]
292#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
293pub enum ResponseIncludable {
294 #[serde(rename = "web_search_call.action.sources")]
295 WebSearchSources,
296 #[serde(rename = "code_interpreter_call.outputs")]
297 CodeInterpreterOutputs,
298 #[serde(rename = "computer_call_output.output.image_url")]
299 ComputerImageUrl,
300 #[serde(rename = "file_search_call.results")]
301 FileSearchResults,
302 #[serde(rename = "message.input_image.image_url")]
303 InputImageUrl,
304 #[serde(rename = "message.output_text.logprobs")]
305 OutputLogprobs,
306 #[serde(rename = "reasoning.encrypted_content")]
307 ReasoningEncryptedContent,
308}
309#[derive(
310 Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
311)]
312#[serde(rename_all = "snake_case")]
313#[derive(gproxy_protocol_macros::DeclaredFields)]
314#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
315pub struct ResponseModeration {
316 pub model: String,
317 #[serde(
318 default,
319 deserialize_with = "present_nullable",
320 skip_serializing_if = "Option::is_none"
321 )]
322 pub policy: Option<Option<ModerationPolicy>>,
323 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
324 pub rest: Rest,
325}
326#[derive(
327 Debug,
328 Clone,
329 Copy,
330 PartialEq,
331 Eq,
332 Serialize,
333 Deserialize,
334 gproxy_protocol_macros::DeclaredFields,
335)]
336#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
337pub enum ModerationMode {
338 #[serde(rename = "score")]
339 Score,
340 #[serde(rename = "block")]
341 Block,
342}
343#[derive(
344 Debug,
345 Clone,
346 PartialEq,
347 Eq,
348 Serialize,
349 Deserialize,
350 gproxy_protocol_macros::WireBuilder,
351 gproxy_protocol_macros::DeclaredFields,
352)]
353#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
354pub struct ModerationPolicy {
355 #[serde(
356 default,
357 deserialize_with = "present_nullable",
358 skip_serializing_if = "Option::is_none"
359 )]
360 pub input: Option<Option<ModerationPolicyMode>>,
361 #[serde(
362 default,
363 deserialize_with = "present_nullable",
364 skip_serializing_if = "Option::is_none"
365 )]
366 pub output: Option<Option<ModerationPolicyMode>>,
367 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
368 pub rest: Rest,
369}
370#[derive(
371 Debug,
372 Clone,
373 PartialEq,
374 Eq,
375 Serialize,
376 Deserialize,
377 gproxy_protocol_macros::WireBuilder,
378 gproxy_protocol_macros::DeclaredFields,
379)]
380#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
381pub struct ModerationPolicyMode {
382 pub mode: ModerationMode,
383 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
384 pub rest: Rest,
385}
386#[derive(
387 Debug,
388 Clone,
389 PartialEq,
390 Eq,
391 Serialize,
392 Deserialize,
393 gproxy_protocol_macros::WireBuilder,
394 gproxy_protocol_macros::DeclaredFields,
395)]
396#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
397pub struct ResponsePrompt {
398 pub id: String,
399 #[serde(
400 default,
401 deserialize_with = "present_nullable",
402 skip_serializing_if = "Option::is_none"
403 )]
404 pub variables: Option<Option<BTreeMap<String, PromptVariableValue>>>,
405 #[serde(
406 default,
407 deserialize_with = "present_nullable",
408 skip_serializing_if = "Option::is_none"
409 )]
410 pub version: Option<Option<String>>,
411 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
412 pub rest: Rest,
413}
414#[derive(
415 Debug,
416 Clone,
417 Copy,
418 PartialEq,
419 Eq,
420 Serialize,
421 Deserialize,
422 gproxy_protocol_macros::DeclaredFields,
423)]
424#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
425pub enum PromptCachingMode {
426 #[serde(rename = "implicit")]
427 Implicit,
428 #[serde(rename = "explicit")]
429 Explicit,
430}
431#[derive(
432 Debug,
433 Clone,
434 PartialEq,
435 Eq,
436 Serialize,
437 Deserialize,
438 gproxy_protocol_macros::WireBuilder,
439 gproxy_protocol_macros::DeclaredFields,
440)]
441#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
442pub struct PromptCacheOptions {
443 #[serde(
444 default,
445 deserialize_with = "present_nullable",
446 skip_serializing_if = "Option::is_none"
447 )]
448 pub comparison_response_id: Option<Option<String>>,
449 #[serde(skip_serializing_if = "Option::is_none")]
450 pub prewarm: Option<bool>,
451
452 #[serde(
453 default,
454 deserialize_with = "present_optional",
455 skip_serializing_if = "Option::is_none"
456 )]
457 pub mode: Option<PromptCachingMode>,
458 #[serde(
459 default,
460 deserialize_with = "present_optional",
461 skip_serializing_if = "Option::is_none"
462 )]
463 pub ttl: Option<PromptCacheTtl>,
464 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
465 pub rest: Rest,
466}
467#[derive(
468 Debug,
469 Clone,
470 Copy,
471 PartialEq,
472 Eq,
473 Serialize,
474 Deserialize,
475 gproxy_protocol_macros::DeclaredFields,
476)]
477#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
478pub enum PromptCacheRetention {
479 #[serde(rename = "in_memory")]
480 InMemory,
481 #[serde(rename = "24h")]
482 TwentyFourHours,
483}
484#[derive(
485 Debug,
486 Clone,
487 Copy,
488 PartialEq,
489 Eq,
490 Serialize,
491 Deserialize,
492 gproxy_protocol_macros::DeclaredFields,
493)]
494#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
495pub enum ServiceTier {
496 #[serde(rename = "auto")]
497 Auto,
498 #[serde(rename = "default")]
499 Default,
500 #[serde(rename = "flex")]
501 Flex,
502 #[serde(rename = "scale")]
503 Scale,
504 #[serde(rename = "priority")]
505 Priority,
506 #[serde(rename = "fast")]
507 Fast,
508 #[serde(rename = "ultrafast")]
509 Ultrafast,
510}
511#[derive(
512 Debug,
513 Clone,
514 PartialEq,
515 Eq,
516 Serialize,
517 Deserialize,
518 gproxy_protocol_macros::WireBuilder,
519 gproxy_protocol_macros::DeclaredFields,
520)]
521#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
522pub struct StreamOptions {
523 #[serde(
524 default,
525 deserialize_with = "present_optional",
526 skip_serializing_if = "Option::is_none"
527 )]
528 pub include_obfuscation: Option<bool>,
529 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
530 pub rest: Rest,
531}
532#[derive(
533 Debug,
534 Clone,
535 Copy,
536 PartialEq,
537 Eq,
538 Serialize,
539 Deserialize,
540 gproxy_protocol_macros::DeclaredFields,
541)]
542#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
543pub enum GenerateTruncation {
544 #[serde(rename = "auto")]
545 Auto,
546 #[serde(rename = "disabled")]
547 Disabled,
548}
549pub type GenerateContentRequest = crate::WireRequest<GenerateContentRequestBody>;
550
551#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
553#[serde(untagged)]
554#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
555#[derive(gproxy_protocol_macros::DeclaredFields)]
556#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
557pub enum PromptVariableValue {
558 String(String),
559 Text(ResponseInputText),
560 Image(ResponseInputImage),
561 File(ResponseInputFile),
562}
563
564#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
567#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
568#[derive(gproxy_protocol_macros::DeclaredFields)]
569#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
570pub enum PromptCacheTtl {
571 #[serde(rename = "30m")]
572 ThirtyMinutes,
573 #[serde(rename = "12h")]
574 TwelveHours,
575}