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