Skip to main content

gproxy_protocol/wire/claude/
generate_content.rs

1use crate::Rest;
2use serde::{Deserialize, Serialize};
3
4use super::{
5    content::{self, Message},
6    count_tokens::{
7        ContextManagementConfig, JsonOutputFormat, McpServerUrlDefinition, OutputConfig, Speed,
8        SystemPrompt, ThinkingConfig, ToolChoice,
9    },
10    tools::ToolUnion,
11};
12
13#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder)]
14#[serde(rename_all = "snake_case")]
15#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
16#[derive(gproxy_protocol_macros::DeclaredFields)]
17pub struct GenerateContentRequestBody {
18    #[serde(skip_serializing_if = "Option::is_none")]
19    pub compaction: Option<CompactionConfig>,
20
21    pub max_tokens: i64,
22    pub messages: Vec<Message>,
23    pub model: String,
24    #[serde(skip_serializing_if = "Option::is_none")]
25    pub cache_control: Option<super::content::CacheControl>,
26    #[serde(skip_serializing_if = "Option::is_none")]
27    pub container: Option<ContainerParam>,
28    #[serde(skip_serializing_if = "Option::is_none")]
29    pub context_management: Option<ContextManagementConfig>,
30    #[serde(skip_serializing_if = "Option::is_none")]
31    pub diagnostics: Option<DiagnosticsParam>,
32    #[serde(skip_serializing_if = "Option::is_none")]
33    pub fallback_credit_token: Option<FallbackCreditTokenParam>,
34    #[serde(skip_serializing_if = "Option::is_none")]
35    pub fallbacks: Option<FallbacksParam>,
36    #[serde(skip_serializing_if = "Option::is_none")]
37    pub inference_geo: Option<String>,
38    #[serde(skip_serializing_if = "Option::is_none")]
39    pub mcp_servers: Option<Vec<McpServerUrlDefinition>>,
40    #[serde(skip_serializing_if = "Option::is_none")]
41    pub metadata: Option<Metadata>,
42    #[serde(skip_serializing_if = "Option::is_none")]
43    pub output_config: Option<OutputConfig>,
44    #[serde(skip_serializing_if = "Option::is_none")]
45    pub output_format: Option<JsonOutputFormat>,
46    #[serde(skip_serializing_if = "Option::is_none")]
47    pub service_tier: Option<ServiceTier>,
48    #[serde(skip_serializing_if = "Option::is_none")]
49    pub speed: Option<Speed>,
50    #[serde(skip_serializing_if = "Option::is_none")]
51    pub stop_sequences: Option<Vec<String>>,
52    #[serde(skip_serializing_if = "Option::is_none")]
53    pub stream: Option<bool>,
54    #[serde(skip_serializing_if = "Option::is_none")]
55    pub system: Option<SystemPrompt>,
56    #[serde(skip_serializing_if = "Option::is_none")]
57    pub temperature: Option<f64>,
58    #[serde(skip_serializing_if = "Option::is_none")]
59    pub thinking: Option<ThinkingConfig>,
60    #[serde(skip_serializing_if = "Option::is_none")]
61    pub tool_choice: Option<ToolChoice>,
62    #[serde(skip_serializing_if = "Option::is_none")]
63    pub tools: Option<Vec<ToolUnion>>,
64    #[serde(skip_serializing_if = "Option::is_none")]
65    pub top_k: Option<i64>,
66    #[serde(skip_serializing_if = "Option::is_none")]
67    pub top_p: Option<f64>,
68    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
69    pub rest: Rest,
70}
71pub type GenerateContentRequest = crate::WireRequest<GenerateContentRequestBody>;
72#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
73#[serde(untagged)]
74#[derive(gproxy_protocol_macros::DeclaredFields)]
75pub enum ContainerParam {
76    Id(String),
77    Params(ContainerParams),
78}
79
80#[derive(
81    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
82)]
83#[serde(rename_all = "snake_case")]
84#[derive(gproxy_protocol_macros::DeclaredFields)]
85pub struct ContainerParams {
86    #[serde(skip_serializing_if = "Option::is_none")]
87    pub id: Option<String>,
88    #[serde(skip_serializing_if = "Option::is_none")]
89    pub skills: Option<Vec<SkillParam>>,
90    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
91    pub rest: Rest,
92}
93#[derive(
94    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
95)]
96#[serde(rename_all = "snake_case")]
97#[derive(gproxy_protocol_macros::DeclaredFields)]
98pub struct SkillParam {
99    pub skill_id: String,
100    #[serde(rename = "type")]
101    pub type_: SkillType,
102    #[serde(skip_serializing_if = "Option::is_none")]
103    pub version: Option<String>,
104    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
105    pub rest: Rest,
106}
107#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
108#[serde(rename_all = "snake_case")]
109#[derive(gproxy_protocol_macros::DeclaredFields)]
110pub enum SkillType {
111    Anthropic,
112    Custom,
113}
114#[derive(
115    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
116)]
117#[serde(rename_all = "snake_case")]
118#[derive(gproxy_protocol_macros::DeclaredFields)]
119pub struct DiagnosticsParam {
120    #[serde(
121        default,
122        deserialize_with = "present_nullable",
123        skip_serializing_if = "Option::is_none"
124    )]
125    pub previous_message_id: Option<Option<String>>,
126    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
127    pub rest: Rest,
128}
129#[derive(
130    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
131)]
132#[serde(rename_all = "snake_case")]
133#[derive(gproxy_protocol_macros::DeclaredFields)]
134pub struct FallbackCreditToken {
135    pub token: String,
136    #[serde(skip_serializing_if = "Option::is_none")]
137    pub mode: Option<FallbackCreditMode>,
138    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
139    pub rest: Rest,
140}
141#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
142#[serde(rename_all = "snake_case")]
143#[derive(gproxy_protocol_macros::DeclaredFields)]
144pub enum FallbackCreditMode {
145    Strict,
146    BestEffort,
147}
148#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder)]
149#[serde(rename_all = "snake_case")]
150#[derive(gproxy_protocol_macros::DeclaredFields)]
151pub struct FallbackParam {
152    pub model: String,
153    #[serde(skip_serializing_if = "Option::is_none")]
154    pub max_tokens: Option<i64>,
155    #[serde(skip_serializing_if = "Option::is_none")]
156    pub output_config: Option<OutputConfig>,
157    #[serde(skip_serializing_if = "Option::is_none")]
158    pub speed: Option<Speed>,
159    #[serde(skip_serializing_if = "Option::is_none")]
160    pub thinking: Option<ThinkingConfig>,
161    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
162    pub rest: Rest,
163}
164#[derive(
165    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
166)]
167#[serde(rename_all = "snake_case")]
168#[derive(gproxy_protocol_macros::DeclaredFields)]
169pub struct Metadata {
170    #[serde(skip_serializing_if = "Option::is_none")]
171    pub user_id: Option<String>,
172    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
173    pub rest: Rest,
174}
175#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
176#[serde(rename_all = "snake_case")]
177#[derive(gproxy_protocol_macros::DeclaredFields)]
178pub enum ServiceTier {
179    Auto,
180    StandardOnly,
181}
182
183// Response nullability follows the official SDK where the generated reference
184// omits it: anthropics/anthropic-sdk-python, src/anthropic/types/beta/.
185// Keep absent fields distinct from explicit null (for example, pending diagnostics).
186fn present_nullable<'de, D, T>(deserializer: D) -> Result<Option<Option<T>>, D::Error>
187where
188    D: serde::Deserializer<'de>,
189    T: Deserialize<'de>,
190{
191    Option::<T>::deserialize(deserializer).map(Some)
192}
193
194#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
195#[serde(untagged)]
196#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
197#[derive(gproxy_protocol_macros::DeclaredFields)]
198pub enum FallbackCreditTokenParam {
199    Token(String),
200    Params(FallbackCreditToken),
201}
202
203#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
204#[serde(untagged)]
205#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
206#[derive(gproxy_protocol_macros::DeclaredFields)]
207pub enum FallbacksParam {
208    Models(Vec<FallbackParam>),
209    Default(DefaultFallbacks),
210}
211
212#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
213#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
214#[derive(gproxy_protocol_macros::DeclaredFields)]
215pub enum DefaultFallbacks {
216    #[serde(rename = "default")]
217    Default,
218}
219
220#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
221#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
222#[derive(gproxy_protocol_macros::DeclaredFields)]
223pub enum GenerateContentResponseBodyType {
224    #[serde(rename = "message")]
225    Tag,
226}
227
228#[derive(
229    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
230)]
231#[serde(rename_all = "snake_case")]
232#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
233#[derive(gproxy_protocol_macros::DeclaredFields)]
234pub struct GenerateContentResponseBody {
235    #[serde(
236        default,
237        deserialize_with = "present_nullable",
238        skip_serializing_if = "Option::is_none"
239    )]
240    pub input_transformations: Option<Option<Vec<InputTransformation>>>,
241
242    #[serde(rename = "type")]
243    pub type_: GenerateContentResponseBodyType,
244    pub id: String,
245    #[serde(
246        default,
247        deserialize_with = "present_nullable",
248        skip_serializing_if = "Option::is_none"
249    )]
250    pub container: Option<Option<ResponseContainer>>,
251    pub content: Vec<ResponseContentBlock>,
252    #[serde(
253        default,
254        deserialize_with = "present_nullable",
255        skip_serializing_if = "Option::is_none"
256    )]
257    pub context_management: Option<Option<ContextManagementResponse>>,
258    #[serde(
259        default,
260        deserialize_with = "present_nullable",
261        skip_serializing_if = "Option::is_none"
262    )]
263    pub diagnostics: Option<Option<DiagnosticsResponse>>,
264    pub model: String,
265    pub role: ResponseRole,
266    #[serde(
267        default,
268        deserialize_with = "present_nullable",
269        skip_serializing_if = "Option::is_none"
270    )]
271    pub stop_details: Option<Option<RefusalStopDetails>>,
272    pub stop_reason: StopReason,
273    #[serde(
274        default,
275        deserialize_with = "present_nullable",
276        skip_serializing_if = "Option::is_none"
277    )]
278    pub stop_sequence: Option<Option<String>>,
279    pub usage: Usage,
280    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
281    pub rest: Rest,
282}
283
284pub type GenerateContentResponse = crate::WireResponse<GenerateContentResponseBody>;
285pub type ResponseType = GenerateContentResponseBodyType;
286#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
287#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
288#[derive(gproxy_protocol_macros::DeclaredFields)]
289pub enum ResponseRole {
290    #[serde(rename = "assistant")]
291    Assistant,
292}
293
294#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
295#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
296#[derive(gproxy_protocol_macros::DeclaredFields)]
297pub enum StopReason {
298    #[serde(rename = "end_turn")]
299    EndTurn,
300    #[serde(rename = "max_tokens")]
301    MaxTokens,
302    #[serde(rename = "stop_sequence")]
303    StopSequence,
304    #[serde(rename = "tool_use")]
305    ToolUse,
306    #[serde(rename = "pause_turn")]
307    PauseTurn,
308    #[serde(rename = "compaction")]
309    Compaction,
310    #[serde(rename = "refusal")]
311    Refusal,
312    #[serde(rename = "model_context_window_exceeded")]
313    ModelContextWindowExceeded,
314}
315
316#[derive(
317    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
318)]
319#[serde(rename_all = "snake_case")]
320#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
321#[derive(gproxy_protocol_macros::DeclaredFields)]
322pub struct ResponseContainer {
323    pub id: String,
324    pub expires_at: String,
325    #[serde(
326        default,
327        deserialize_with = "present_nullable",
328        skip_serializing_if = "Option::is_none"
329    )]
330    pub skills: Option<Option<Vec<ResponseSkill>>>,
331    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
332    pub rest: Rest,
333}
334
335#[derive(
336    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
337)]
338#[serde(rename_all = "snake_case")]
339#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
340#[derive(gproxy_protocol_macros::DeclaredFields)]
341pub struct ResponseSkill {
342    pub skill_id: String,
343    #[serde(rename = "type")]
344    pub type_: SkillType,
345    pub version: String,
346    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
347    pub rest: Rest,
348}
349
350#[derive(
351    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
352)]
353#[serde(rename_all = "snake_case")]
354#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
355#[derive(gproxy_protocol_macros::DeclaredFields)]
356pub struct ContextManagementResponse {
357    pub applied_edits: Vec<ContextEditResponse>,
358    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
359    pub rest: Rest,
360}
361
362#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
363#[serde(untagged)]
364#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
365#[derive(gproxy_protocol_macros::DeclaredFields)]
366pub enum ContextEditResponse {
367    Tools(ClearedTools),
368    Thinking(ClearedThinking),
369}
370
371#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
372#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
373#[derive(gproxy_protocol_macros::DeclaredFields)]
374pub enum ClearedToolsType {
375    #[serde(rename = "clear_tool_uses_20250919")]
376    Tag,
377}
378
379#[derive(
380    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
381)]
382#[serde(rename_all = "snake_case")]
383#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
384#[derive(gproxy_protocol_macros::DeclaredFields)]
385pub struct ClearedTools {
386    #[serde(rename = "type")]
387    pub type_: ClearedToolsType,
388    pub cleared_input_tokens: i64,
389    pub cleared_tool_uses: i64,
390    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
391    pub rest: Rest,
392}
393
394#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
395#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
396#[derive(gproxy_protocol_macros::DeclaredFields)]
397pub enum ClearedThinkingType {
398    #[serde(rename = "clear_thinking_20251015")]
399    Tag,
400}
401
402#[derive(
403    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
404)]
405#[serde(rename_all = "snake_case")]
406#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
407#[derive(gproxy_protocol_macros::DeclaredFields)]
408pub struct ClearedThinking {
409    #[serde(rename = "type")]
410    pub type_: ClearedThinkingType,
411    pub cleared_input_tokens: i64,
412    pub cleared_thinking_turns: i64,
413    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
414    pub rest: Rest,
415}
416
417#[derive(
418    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
419)]
420#[serde(rename_all = "snake_case")]
421#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
422#[derive(gproxy_protocol_macros::DeclaredFields)]
423pub struct DiagnosticsResponse {
424    #[serde(
425        default,
426        deserialize_with = "present_nullable",
427        skip_serializing_if = "Option::is_none"
428    )]
429    pub cache_miss_reason: Option<Option<CacheMissReason>>,
430    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
431    pub rest: Rest,
432}
433
434#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
435#[serde(untagged)]
436#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
437#[derive(gproxy_protocol_macros::DeclaredFields)]
438pub enum CacheMissReason {
439    ModelChanged(CacheMissModelChanged),
440    SystemChanged(CacheMissSystemChanged),
441    ToolsChanged(CacheMissToolsChanged),
442    MessagesChanged(CacheMissMessagesChanged),
443    PreviousMessageNotFound(CacheMissPreviousMessageNotFound),
444    Unavailable(CacheMissUnavailable),
445}
446
447#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
448#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
449#[derive(gproxy_protocol_macros::DeclaredFields)]
450pub enum CacheMissModelChangedType {
451    #[serde(rename = "model_changed")]
452    Tag,
453}
454
455#[derive(
456    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
457)]
458#[serde(rename_all = "snake_case")]
459#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
460#[derive(gproxy_protocol_macros::DeclaredFields)]
461pub struct CacheMissModelChanged {
462    #[serde(rename = "type")]
463    pub type_: CacheMissModelChangedType,
464    pub cache_missed_input_tokens: i64,
465    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
466    pub rest: Rest,
467}
468
469#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
470#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
471#[derive(gproxy_protocol_macros::DeclaredFields)]
472pub enum CacheMissSystemChangedType {
473    #[serde(rename = "system_changed")]
474    Tag,
475}
476
477#[derive(
478    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
479)]
480#[serde(rename_all = "snake_case")]
481#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
482#[derive(gproxy_protocol_macros::DeclaredFields)]
483pub struct CacheMissSystemChanged {
484    #[serde(rename = "type")]
485    pub type_: CacheMissSystemChangedType,
486    pub cache_missed_input_tokens: i64,
487    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
488    pub rest: Rest,
489}
490
491#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
492#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
493#[derive(gproxy_protocol_macros::DeclaredFields)]
494pub enum CacheMissToolsChangedType {
495    #[serde(rename = "tools_changed")]
496    Tag,
497}
498
499#[derive(
500    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
501)]
502#[serde(rename_all = "snake_case")]
503#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
504#[derive(gproxy_protocol_macros::DeclaredFields)]
505pub struct CacheMissToolsChanged {
506    #[serde(rename = "type")]
507    pub type_: CacheMissToolsChangedType,
508    pub cache_missed_input_tokens: i64,
509    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
510    pub rest: Rest,
511}
512
513#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
514#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
515#[derive(gproxy_protocol_macros::DeclaredFields)]
516pub enum CacheMissMessagesChangedType {
517    #[serde(rename = "messages_changed")]
518    Tag,
519}
520
521#[derive(
522    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
523)]
524#[serde(rename_all = "snake_case")]
525#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
526#[derive(gproxy_protocol_macros::DeclaredFields)]
527pub struct CacheMissMessagesChanged {
528    #[serde(rename = "type")]
529    pub type_: CacheMissMessagesChangedType,
530    pub cache_missed_input_tokens: i64,
531    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
532    pub rest: Rest,
533}
534
535#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
536#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
537#[derive(gproxy_protocol_macros::DeclaredFields)]
538pub enum CacheMissPreviousMessageNotFoundType {
539    #[serde(rename = "previous_message_not_found")]
540    Tag,
541}
542
543#[derive(
544    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
545)]
546#[serde(rename_all = "snake_case")]
547#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
548#[derive(gproxy_protocol_macros::DeclaredFields)]
549pub struct CacheMissPreviousMessageNotFound {
550    #[serde(rename = "type")]
551    pub type_: CacheMissPreviousMessageNotFoundType,
552    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
553    pub rest: Rest,
554}
555
556#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
557#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
558#[derive(gproxy_protocol_macros::DeclaredFields)]
559pub enum CacheMissUnavailableType {
560    #[serde(rename = "unavailable")]
561    Tag,
562}
563
564#[derive(
565    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
566)]
567#[serde(rename_all = "snake_case")]
568#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
569#[derive(gproxy_protocol_macros::DeclaredFields)]
570pub struct CacheMissUnavailable {
571    #[serde(rename = "type")]
572    pub type_: CacheMissUnavailableType,
573    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
574    pub rest: Rest,
575}
576
577#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
578#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
579#[derive(gproxy_protocol_macros::DeclaredFields)]
580pub enum RefusalCategory {
581    #[serde(rename = "cyber")]
582    Cyber,
583    #[serde(rename = "bio")]
584    Bio,
585    #[serde(rename = "frontier_llm")]
586    FrontierLlm,
587    #[serde(rename = "reasoning_extraction")]
588    ReasoningExtraction,
589    #[serde(rename = "general_harms")]
590    GeneralHarms,
591}
592
593#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
594#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
595#[derive(gproxy_protocol_macros::DeclaredFields)]
596pub enum RefusalStopDetailsType {
597    #[serde(rename = "refusal")]
598    Tag,
599}
600
601#[derive(
602    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
603)]
604#[serde(rename_all = "snake_case")]
605#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
606#[derive(gproxy_protocol_macros::DeclaredFields)]
607pub struct RefusalStopDetails {
608    #[serde(rename = "type")]
609    pub type_: RefusalStopDetailsType,
610    #[serde(
611        default,
612        deserialize_with = "present_nullable",
613        skip_serializing_if = "Option::is_none"
614    )]
615    pub category: Option<Option<RefusalCategory>>,
616    #[serde(
617        default,
618        deserialize_with = "present_nullable",
619        skip_serializing_if = "Option::is_none"
620    )]
621    pub explanation: Option<Option<String>>,
622    #[serde(
623        default,
624        deserialize_with = "present_nullable",
625        skip_serializing_if = "Option::is_none"
626    )]
627    pub fallback_credit_token: Option<Option<String>>,
628    #[serde(
629        default,
630        deserialize_with = "present_nullable",
631        skip_serializing_if = "Option::is_none"
632    )]
633    pub fallback_has_prefill_claim: Option<Option<bool>>,
634    #[serde(
635        default,
636        deserialize_with = "present_nullable",
637        skip_serializing_if = "Option::is_none"
638    )]
639    pub recommended_model: Option<Option<String>>,
640    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
641    pub rest: Rest,
642}
643
644#[derive(
645    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
646)]
647#[serde(rename_all = "snake_case")]
648#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
649#[derive(gproxy_protocol_macros::DeclaredFields)]
650pub struct CacheCreation {
651    pub ephemeral_1h_input_tokens: i64,
652    pub ephemeral_5m_input_tokens: i64,
653    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
654    pub rest: Rest,
655}
656
657#[derive(
658    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
659)]
660#[serde(rename_all = "snake_case")]
661#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
662#[derive(gproxy_protocol_macros::DeclaredFields)]
663pub struct Usage {
664    #[serde(
665        default,
666        deserialize_with = "present_nullable",
667        skip_serializing_if = "Option::is_none"
668    )]
669    pub cache_creation: Option<Option<CacheCreation>>,
670    #[serde(
671        default,
672        deserialize_with = "present_nullable",
673        skip_serializing_if = "Option::is_none"
674    )]
675    pub cache_creation_input_tokens: Option<Option<i64>>,
676    #[serde(
677        default,
678        deserialize_with = "present_nullable",
679        skip_serializing_if = "Option::is_none"
680    )]
681    pub cache_read_input_tokens: Option<Option<i64>>,
682    #[serde(
683        default,
684        deserialize_with = "present_nullable",
685        skip_serializing_if = "Option::is_none"
686    )]
687    pub fallback_credit: Option<Option<FallbackCreditUsage>>,
688    #[serde(
689        default,
690        deserialize_with = "present_nullable",
691        skip_serializing_if = "Option::is_none"
692    )]
693    pub inference_geo: Option<Option<String>>,
694    pub input_tokens: i64,
695    #[serde(
696        default,
697        deserialize_with = "present_nullable",
698        skip_serializing_if = "Option::is_none"
699    )]
700    pub iterations: Option<Option<Vec<IterationUsage>>>,
701    pub output_tokens: i64,
702    #[serde(
703        default,
704        deserialize_with = "present_nullable",
705        skip_serializing_if = "Option::is_none"
706    )]
707    pub output_tokens_details: Option<Option<OutputTokensDetails>>,
708    #[serde(
709        default,
710        deserialize_with = "present_nullable",
711        skip_serializing_if = "Option::is_none"
712    )]
713    pub server_tool_use: Option<Option<ServerToolUsage>>,
714    #[serde(
715        default,
716        deserialize_with = "present_nullable",
717        skip_serializing_if = "Option::is_none"
718    )]
719    pub service_tier: Option<Option<ResponseServiceTier>>,
720    #[serde(
721        default,
722        deserialize_with = "present_nullable",
723        skip_serializing_if = "Option::is_none"
724    )]
725    pub speed: Option<Option<Speed>>,
726    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
727    pub rest: Rest,
728}
729
730#[derive(
731    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
732)]
733#[serde(rename_all = "snake_case")]
734#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
735#[derive(gproxy_protocol_macros::DeclaredFields)]
736pub struct OutputTokensDetails {
737    pub thinking_tokens: i64,
738    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
739    pub rest: Rest,
740}
741
742#[derive(
743    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
744)]
745#[serde(rename_all = "snake_case")]
746#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
747#[derive(gproxy_protocol_macros::DeclaredFields)]
748pub struct ServerToolUsage {
749    pub web_fetch_requests: i64,
750    pub web_search_requests: i64,
751    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
752    pub rest: Rest,
753}
754
755#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
756#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
757#[derive(gproxy_protocol_macros::DeclaredFields)]
758pub enum ResponseServiceTier {
759    #[serde(rename = "standard")]
760    Standard,
761    #[serde(rename = "priority")]
762    Priority,
763    #[serde(rename = "batch")]
764    Batch,
765}
766
767#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
768#[serde(untagged)]
769#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
770#[derive(gproxy_protocol_macros::DeclaredFields)]
771pub enum IterationUsage {
772    Message(MessageIterationUsage),
773    Compaction(CompactionIterationUsage),
774    Advisor(AdvisorMessageIterationUsage),
775    Fallback(FallbackMessageIterationUsage),
776}
777
778#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
779#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
780#[derive(gproxy_protocol_macros::DeclaredFields)]
781pub enum MessageIterationUsageType {
782    #[serde(rename = "message")]
783    Tag,
784}
785
786#[derive(
787    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
788)]
789#[serde(rename_all = "snake_case")]
790#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
791#[derive(gproxy_protocol_macros::DeclaredFields)]
792pub struct MessageIterationUsage {
793    #[serde(rename = "type")]
794    pub type_: MessageIterationUsageType,
795    #[serde(
796        default,
797        deserialize_with = "present_nullable",
798        skip_serializing_if = "Option::is_none"
799    )]
800    pub cache_creation: Option<Option<CacheCreation>>,
801    pub cache_creation_input_tokens: i64,
802    pub cache_read_input_tokens: i64,
803    pub input_tokens: i64,
804    pub model: String,
805    pub output_tokens: i64,
806    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
807    pub rest: Rest,
808}
809
810#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
811#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
812#[derive(gproxy_protocol_macros::DeclaredFields)]
813pub enum CompactionIterationUsageType {
814    #[serde(rename = "compaction")]
815    Tag,
816}
817
818#[derive(
819    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
820)]
821#[serde(rename_all = "snake_case")]
822#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
823#[derive(gproxy_protocol_macros::DeclaredFields)]
824pub struct CompactionIterationUsage {
825    #[serde(rename = "type")]
826    pub type_: CompactionIterationUsageType,
827    #[serde(
828        default,
829        deserialize_with = "present_nullable",
830        skip_serializing_if = "Option::is_none"
831    )]
832    pub cache_creation: Option<Option<CacheCreation>>,
833    pub cache_creation_input_tokens: i64,
834    pub cache_read_input_tokens: i64,
835    pub input_tokens: i64,
836    pub output_tokens: i64,
837    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
838    pub rest: Rest,
839}
840
841#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
842#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
843#[derive(gproxy_protocol_macros::DeclaredFields)]
844pub enum AdvisorMessageIterationUsageType {
845    #[serde(rename = "advisor_message")]
846    Tag,
847}
848
849#[derive(
850    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
851)]
852#[serde(rename_all = "snake_case")]
853#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
854#[derive(gproxy_protocol_macros::DeclaredFields)]
855pub struct AdvisorMessageIterationUsage {
856    #[serde(rename = "type")]
857    pub type_: AdvisorMessageIterationUsageType,
858    #[serde(
859        default,
860        deserialize_with = "present_nullable",
861        skip_serializing_if = "Option::is_none"
862    )]
863    pub cache_creation: Option<Option<CacheCreation>>,
864    pub cache_creation_input_tokens: i64,
865    pub cache_read_input_tokens: i64,
866    pub input_tokens: i64,
867    pub model: String,
868    pub output_tokens: i64,
869    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
870    pub rest: Rest,
871}
872
873#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
874#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
875#[derive(gproxy_protocol_macros::DeclaredFields)]
876pub enum FallbackMessageIterationUsageType {
877    #[serde(rename = "fallback_message")]
878    Tag,
879}
880
881#[derive(
882    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
883)]
884#[serde(rename_all = "snake_case")]
885#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
886#[derive(gproxy_protocol_macros::DeclaredFields)]
887pub struct FallbackMessageIterationUsage {
888    #[serde(rename = "type")]
889    pub type_: FallbackMessageIterationUsageType,
890    #[serde(
891        default,
892        deserialize_with = "present_nullable",
893        skip_serializing_if = "Option::is_none"
894    )]
895    pub cache_creation: Option<Option<CacheCreation>>,
896    pub cache_creation_input_tokens: i64,
897    pub cache_read_input_tokens: i64,
898    pub input_tokens: i64,
899    pub model: String,
900    pub output_tokens: i64,
901    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
902    pub rest: Rest,
903}
904
905#[derive(
906    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
907)]
908#[serde(rename_all = "snake_case")]
909#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
910#[derive(gproxy_protocol_macros::DeclaredFields)]
911pub struct FallbackCreditUsage {
912    pub status: FallbackCreditStatus,
913    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
914    pub rest: Rest,
915}
916
917#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
918#[serde(untagged)]
919#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
920#[derive(gproxy_protocol_macros::DeclaredFields)]
921pub enum FallbackCreditStatus {
922    Redeemed(FallbackRedeemed),
923    NotApplied(FallbackNotApplied),
924}
925
926#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
927#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
928#[derive(gproxy_protocol_macros::DeclaredFields)]
929pub enum FallbackRedeemedType {
930    #[serde(rename = "redeemed")]
931    Tag,
932}
933
934#[derive(
935    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
936)]
937#[serde(rename_all = "snake_case")]
938#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
939#[derive(gproxy_protocol_macros::DeclaredFields)]
940pub struct FallbackRedeemed {
941    #[serde(rename = "type")]
942    pub type_: FallbackRedeemedType,
943    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
944    pub rest: Rest,
945}
946
947#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
948#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
949#[derive(gproxy_protocol_macros::DeclaredFields)]
950pub enum FallbackNotAppliedType {
951    #[serde(rename = "not_applied")]
952    Tag,
953}
954
955#[derive(
956    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
957)]
958#[serde(rename_all = "snake_case")]
959#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
960#[derive(gproxy_protocol_macros::DeclaredFields)]
961pub struct FallbackNotApplied {
962    #[serde(rename = "type")]
963    pub type_: FallbackNotAppliedType,
964    pub reason: FallbackNotAppliedReason,
965    #[serde(skip_serializing_if = "Option::is_none")]
966    pub remove_to_redeem: Option<Vec<String>>,
967    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
968    pub rest: Rest,
969}
970
971#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
972#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
973#[derive(gproxy_protocol_macros::DeclaredFields)]
974pub enum FallbackNotAppliedReason {
975    #[serde(rename = "body_mismatch")]
976    BodyMismatch,
977    #[serde(rename = "continuation_excluded")]
978    ContinuationExcluded,
979    #[serde(rename = "continuation_only")]
980    ContinuationOnly,
981    #[serde(rename = "expired")]
982    Expired,
983    #[serde(rename = "invalid_target_model")]
984    InvalidTargetModel,
985    #[serde(rename = "not_enabled")]
986    NotEnabled,
987    #[serde(rename = "reprice_unavailable")]
988    RepriceUnavailable,
989    #[serde(rename = "temporarily_unavailable")]
990    TemporarilyUnavailable,
991    #[serde(rename = "variant_fields_present")]
992    VariantFieldsPresent,
993    #[serde(rename = "wrong_organization")]
994    WrongOrganization,
995    #[serde(rename = "wrong_platform")]
996    WrongPlatform,
997    #[serde(rename = "wrong_workspace")]
998    WrongWorkspace,
999}
1000
1001// The response union deliberately excludes request-only image/document/tool-result
1002// and conversation-edit blocks. Shared leaves below have identical wire contracts.
1003#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1004#[serde(untagged)]
1005#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1006#[derive(gproxy_protocol_macros::DeclaredFields)]
1007pub enum ResponseContentBlock {
1008    Text(ResponseTextBlock),
1009    Thinking(content::ThinkingBlock),
1010    RedactedThinking(content::RedactedThinkingBlock),
1011    ToolUse(ResponseToolUseBlock),
1012    ServerToolUse(ResponseServerToolUseBlock),
1013    WebSearchToolResult(ResponseWebSearchToolResultBlock),
1014    WebFetchToolResult(ResponseWebFetchToolResultBlock),
1015    AdvisorToolResult(ResponseAdvisorToolResultBlock),
1016    CodeExecutionToolResult(ResponseCodeExecutionToolResultBlock),
1017    BashCodeExecutionToolResult(ResponseBashCodeExecutionToolResultBlock),
1018    TextEditorCodeExecutionToolResult(ResponseTextEditorCodeExecutionToolResultBlock),
1019    ToolSearchToolResult(ResponseToolSearchToolResultBlock),
1020    McpToolListing(content::McpToolListingBlock),
1021    McpToolUse(ResponseMcpToolUseBlock),
1022    McpToolResult(ResponseMcpToolResultBlock),
1023    ContainerUpload(ResponseContainerUploadBlock),
1024    Compaction(ResponseCompactionBlock),
1025    Fallback(ResponseFallbackBlock),
1026}
1027
1028#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1029#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1030#[derive(gproxy_protocol_macros::DeclaredFields)]
1031pub enum ResponseTextBlockType {
1032    #[serde(rename = "text")]
1033    Tag,
1034}
1035
1036#[derive(
1037    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1038)]
1039#[serde(rename_all = "snake_case")]
1040#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1041#[derive(gproxy_protocol_macros::DeclaredFields)]
1042pub struct ResponseTextBlock {
1043    #[serde(rename = "type")]
1044    pub type_: ResponseTextBlockType,
1045    #[serde(
1046        default,
1047        deserialize_with = "present_nullable",
1048        skip_serializing_if = "Option::is_none"
1049    )]
1050    pub citations: Option<Option<Vec<ResponseTextCitation>>>,
1051    pub text: String,
1052    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1053    pub rest: Rest,
1054}
1055
1056#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1057#[serde(untagged)]
1058#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1059#[derive(gproxy_protocol_macros::DeclaredFields)]
1060pub enum ResponseTextCitation {
1061    Char(ResponseCharCitation),
1062    Page(ResponsePageCitation),
1063    ContentBlock(ResponseContentBlockCitation),
1064    Web(ResponseWebCitation),
1065    Search(ResponseSearchCitation),
1066}
1067
1068#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1069#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1070#[derive(gproxy_protocol_macros::DeclaredFields)]
1071pub enum ResponseCharCitationType {
1072    #[serde(rename = "char_location")]
1073    Tag,
1074}
1075
1076#[derive(
1077    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1078)]
1079#[serde(rename_all = "snake_case")]
1080#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1081#[derive(gproxy_protocol_macros::DeclaredFields)]
1082pub struct ResponseCharCitation {
1083    #[serde(rename = "type")]
1084    pub type_: ResponseCharCitationType,
1085    pub cited_text: String,
1086    pub document_index: i64,
1087    #[serde(
1088        default,
1089        deserialize_with = "present_nullable",
1090        skip_serializing_if = "Option::is_none"
1091    )]
1092    pub document_title: Option<Option<String>>,
1093    #[serde(
1094        default,
1095        deserialize_with = "present_nullable",
1096        skip_serializing_if = "Option::is_none"
1097    )]
1098    pub file_id: Option<Option<String>>,
1099    pub end_char_index: i64,
1100    pub start_char_index: i64,
1101    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1102    pub rest: Rest,
1103}
1104
1105#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1106#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1107#[derive(gproxy_protocol_macros::DeclaredFields)]
1108pub enum ResponsePageCitationType {
1109    #[serde(rename = "page_location")]
1110    Tag,
1111}
1112
1113#[derive(
1114    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1115)]
1116#[serde(rename_all = "snake_case")]
1117#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1118#[derive(gproxy_protocol_macros::DeclaredFields)]
1119pub struct ResponsePageCitation {
1120    #[serde(rename = "type")]
1121    pub type_: ResponsePageCitationType,
1122    pub cited_text: String,
1123    pub document_index: i64,
1124    #[serde(
1125        default,
1126        deserialize_with = "present_nullable",
1127        skip_serializing_if = "Option::is_none"
1128    )]
1129    pub document_title: Option<Option<String>>,
1130    #[serde(
1131        default,
1132        deserialize_with = "present_nullable",
1133        skip_serializing_if = "Option::is_none"
1134    )]
1135    pub file_id: Option<Option<String>>,
1136    pub end_page_number: i64,
1137    pub start_page_number: i64,
1138    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1139    pub rest: Rest,
1140}
1141
1142#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1143#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1144#[derive(gproxy_protocol_macros::DeclaredFields)]
1145pub enum ResponseContentBlockCitationType {
1146    #[serde(rename = "content_block_location")]
1147    Tag,
1148}
1149
1150#[derive(
1151    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1152)]
1153#[serde(rename_all = "snake_case")]
1154#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1155#[derive(gproxy_protocol_macros::DeclaredFields)]
1156pub struct ResponseContentBlockCitation {
1157    #[serde(rename = "type")]
1158    pub type_: ResponseContentBlockCitationType,
1159    pub cited_text: String,
1160    pub document_index: i64,
1161    #[serde(
1162        default,
1163        deserialize_with = "present_nullable",
1164        skip_serializing_if = "Option::is_none"
1165    )]
1166    pub document_title: Option<Option<String>>,
1167    #[serde(
1168        default,
1169        deserialize_with = "present_nullable",
1170        skip_serializing_if = "Option::is_none"
1171    )]
1172    pub file_id: Option<Option<String>>,
1173    pub end_block_index: i64,
1174    pub start_block_index: i64,
1175    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1176    pub rest: Rest,
1177}
1178
1179#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1180#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1181#[derive(gproxy_protocol_macros::DeclaredFields)]
1182pub enum ResponseWebCitationType {
1183    #[serde(rename = "web_search_result_location")]
1184    Tag,
1185}
1186
1187#[derive(
1188    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1189)]
1190#[serde(rename_all = "snake_case")]
1191#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1192#[derive(gproxy_protocol_macros::DeclaredFields)]
1193pub struct ResponseWebCitation {
1194    #[serde(rename = "type")]
1195    pub type_: ResponseWebCitationType,
1196    pub cited_text: String,
1197    pub encrypted_index: String,
1198    #[serde(
1199        default,
1200        deserialize_with = "present_nullable",
1201        skip_serializing_if = "Option::is_none"
1202    )]
1203    pub title: Option<Option<String>>,
1204    pub url: String,
1205    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1206    pub rest: Rest,
1207}
1208
1209#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1210#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1211#[derive(gproxy_protocol_macros::DeclaredFields)]
1212pub enum ResponseSearchCitationType {
1213    #[serde(rename = "search_result_location")]
1214    Tag,
1215}
1216
1217#[derive(
1218    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1219)]
1220#[serde(rename_all = "snake_case")]
1221#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1222#[derive(gproxy_protocol_macros::DeclaredFields)]
1223pub struct ResponseSearchCitation {
1224    #[serde(rename = "type")]
1225    pub type_: ResponseSearchCitationType,
1226    pub cited_text: String,
1227    pub end_block_index: i64,
1228    pub search_result_index: i64,
1229    pub source: String,
1230    pub start_block_index: i64,
1231    #[serde(
1232        default,
1233        deserialize_with = "present_nullable",
1234        skip_serializing_if = "Option::is_none"
1235    )]
1236    pub title: Option<Option<String>>,
1237    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1238    pub rest: Rest,
1239}
1240
1241#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1242#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1243#[derive(gproxy_protocol_macros::DeclaredFields)]
1244pub enum ResponseToolUseBlockType {
1245    #[serde(rename = "tool_use")]
1246    Tag,
1247}
1248
1249#[derive(
1250    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1251)]
1252#[serde(rename_all = "snake_case")]
1253#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1254#[derive(gproxy_protocol_macros::DeclaredFields)]
1255pub struct ResponseToolUseBlock {
1256    #[serde(
1257        default,
1258        deserialize_with = "present_nullable",
1259        skip_serializing_if = "Option::is_none"
1260    )]
1261    pub toolset_name: Option<Option<String>>,
1262
1263    #[serde(rename = "type")]
1264    pub type_: ResponseToolUseBlockType,
1265    pub id: String,
1266    pub input: serde_json::Map<String, serde_json::Value>,
1267    pub name: String,
1268    #[serde(
1269        default,
1270        deserialize_with = "present_nullable",
1271        skip_serializing_if = "Option::is_none"
1272    )]
1273    pub caller: Option<Option<content::Caller>>,
1274    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1275    pub rest: Rest,
1276}
1277
1278#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1279#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1280#[derive(gproxy_protocol_macros::DeclaredFields)]
1281pub enum ResponseServerToolUseBlockType {
1282    #[serde(rename = "server_tool_use")]
1283    Tag,
1284}
1285
1286#[derive(
1287    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1288)]
1289#[serde(rename_all = "snake_case")]
1290#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1291#[derive(gproxy_protocol_macros::DeclaredFields)]
1292pub struct ResponseServerToolUseBlock {
1293    #[serde(rename = "type")]
1294    pub type_: ResponseServerToolUseBlockType,
1295    pub id: String,
1296    pub input: serde_json::Map<String, serde_json::Value>,
1297    pub name: content::ServerToolName,
1298    #[serde(
1299        default,
1300        deserialize_with = "present_nullable",
1301        skip_serializing_if = "Option::is_none"
1302    )]
1303    pub caller: Option<Option<content::Caller>>,
1304    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1305    pub rest: Rest,
1306}
1307
1308#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1309#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1310#[derive(gproxy_protocol_macros::DeclaredFields)]
1311pub enum ResponseWebSearchToolResultBlockType {
1312    #[serde(rename = "web_search_tool_result")]
1313    Tag,
1314}
1315
1316#[derive(
1317    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1318)]
1319#[serde(rename_all = "snake_case")]
1320#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1321#[derive(gproxy_protocol_macros::DeclaredFields)]
1322pub struct ResponseWebSearchToolResultBlock {
1323    #[serde(rename = "type")]
1324    pub type_: ResponseWebSearchToolResultBlockType,
1325    pub content: ResponseWebSearchResultContent,
1326    pub tool_use_id: String,
1327    #[serde(
1328        default,
1329        deserialize_with = "present_nullable",
1330        skip_serializing_if = "Option::is_none"
1331    )]
1332    pub caller: Option<Option<content::Caller>>,
1333    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1334    pub rest: Rest,
1335}
1336
1337#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1338#[serde(untagged)]
1339#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1340#[derive(gproxy_protocol_macros::DeclaredFields)]
1341pub enum ResponseWebSearchResultContent {
1342    Error(content::WebSearchError),
1343    Results(Vec<ResponseWebSearchResult>),
1344}
1345
1346#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1347#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1348#[derive(gproxy_protocol_macros::DeclaredFields)]
1349pub enum ResponseWebSearchResultType {
1350    #[serde(rename = "web_search_result")]
1351    Tag,
1352}
1353
1354#[derive(
1355    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1356)]
1357#[serde(rename_all = "snake_case")]
1358#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1359#[derive(gproxy_protocol_macros::DeclaredFields)]
1360pub struct ResponseWebSearchResult {
1361    #[serde(rename = "type")]
1362    pub type_: ResponseWebSearchResultType,
1363    pub encrypted_content: String,
1364    #[serde(
1365        default,
1366        deserialize_with = "present_nullable",
1367        skip_serializing_if = "Option::is_none"
1368    )]
1369    pub page_age: Option<Option<String>>,
1370    pub title: String,
1371    pub url: String,
1372    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1373    pub rest: Rest,
1374}
1375
1376#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1377#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1378#[derive(gproxy_protocol_macros::DeclaredFields)]
1379pub enum ResponseWebFetchToolResultBlockType {
1380    #[serde(rename = "web_fetch_tool_result")]
1381    Tag,
1382}
1383
1384#[derive(
1385    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1386)]
1387#[serde(rename_all = "snake_case")]
1388#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1389#[derive(gproxy_protocol_macros::DeclaredFields)]
1390pub struct ResponseWebFetchToolResultBlock {
1391    #[serde(rename = "type")]
1392    pub type_: ResponseWebFetchToolResultBlockType,
1393    pub content: ResponseWebFetchResultContent,
1394    pub tool_use_id: String,
1395    #[serde(
1396        default,
1397        deserialize_with = "present_nullable",
1398        skip_serializing_if = "Option::is_none"
1399    )]
1400    pub caller: Option<Option<content::Caller>>,
1401    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1402    pub rest: Rest,
1403}
1404
1405#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1406#[serde(untagged)]
1407#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1408#[derive(gproxy_protocol_macros::DeclaredFields)]
1409pub enum ResponseWebFetchResultContent {
1410    Error(content::WebFetchError),
1411    Result(ResponseWebFetchResult),
1412}
1413
1414#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1415#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1416#[derive(gproxy_protocol_macros::DeclaredFields)]
1417pub enum ResponseWebFetchResultType {
1418    #[serde(rename = "web_fetch_result")]
1419    Tag,
1420}
1421
1422#[derive(
1423    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1424)]
1425#[serde(rename_all = "snake_case")]
1426#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1427#[derive(gproxy_protocol_macros::DeclaredFields)]
1428pub struct ResponseWebFetchResult {
1429    #[serde(rename = "type")]
1430    pub type_: ResponseWebFetchResultType,
1431    pub content: ResponseDocumentBlock,
1432    #[serde(
1433        default,
1434        deserialize_with = "present_nullable",
1435        skip_serializing_if = "Option::is_none"
1436    )]
1437    pub retrieved_at: Option<Option<String>>,
1438    pub url: String,
1439    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1440    pub rest: Rest,
1441}
1442
1443#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1444#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1445#[derive(gproxy_protocol_macros::DeclaredFields)]
1446pub enum ResponseDocumentBlockType {
1447    #[serde(rename = "document")]
1448    Tag,
1449}
1450
1451#[derive(
1452    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1453)]
1454#[serde(rename_all = "snake_case")]
1455#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1456#[derive(gproxy_protocol_macros::DeclaredFields)]
1457pub struct ResponseDocumentBlock {
1458    #[serde(rename = "type")]
1459    pub type_: ResponseDocumentBlockType,
1460    #[serde(
1461        default,
1462        deserialize_with = "present_nullable",
1463        skip_serializing_if = "Option::is_none"
1464    )]
1465    pub citations: Option<Option<ResponseCitationConfig>>,
1466    pub source: ResponseDocumentSource,
1467    #[serde(
1468        default,
1469        deserialize_with = "present_nullable",
1470        skip_serializing_if = "Option::is_none"
1471    )]
1472    pub title: Option<Option<String>>,
1473    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1474    pub rest: Rest,
1475}
1476
1477#[derive(
1478    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1479)]
1480#[serde(rename_all = "snake_case")]
1481#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1482#[derive(gproxy_protocol_macros::DeclaredFields)]
1483pub struct ResponseCitationConfig {
1484    pub enabled: bool,
1485    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1486    pub rest: Rest,
1487}
1488
1489#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1490#[serde(tag = "type")]
1491#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1492#[derive(gproxy_protocol_macros::DeclaredFields)]
1493pub enum ResponseDocumentSource {
1494    #[serde(rename = "base64")]
1495    Base64(content::PdfBase64Source),
1496    #[serde(rename = "text")]
1497    Text(content::PlainTextSource),
1498}
1499
1500#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1501#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1502#[derive(gproxy_protocol_macros::DeclaredFields)]
1503pub enum ResponseAdvisorToolResultBlockType {
1504    #[serde(rename = "advisor_tool_result")]
1505    Tag,
1506}
1507
1508#[derive(
1509    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1510)]
1511#[serde(rename_all = "snake_case")]
1512#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1513#[derive(gproxy_protocol_macros::DeclaredFields)]
1514pub struct ResponseAdvisorToolResultBlock {
1515    #[serde(rename = "type")]
1516    pub type_: ResponseAdvisorToolResultBlockType,
1517    pub content: ResponseAdvisorResultContent,
1518    pub tool_use_id: String,
1519    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1520    pub rest: Rest,
1521}
1522
1523#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1524#[serde(untagged)]
1525#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1526#[derive(gproxy_protocol_macros::DeclaredFields)]
1527pub enum ResponseAdvisorResultContent {
1528    Error(content::AdvisorError),
1529    Result(ResponseAdvisorResult),
1530    Redacted(ResponseAdvisorRedactedResult),
1531}
1532
1533#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1534#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1535#[derive(gproxy_protocol_macros::DeclaredFields)]
1536pub enum ResponseAdvisorResultType {
1537    #[serde(rename = "advisor_result")]
1538    Tag,
1539}
1540
1541#[derive(
1542    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1543)]
1544#[serde(rename_all = "snake_case")]
1545#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1546#[derive(gproxy_protocol_macros::DeclaredFields)]
1547pub struct ResponseAdvisorResult {
1548    #[serde(rename = "type")]
1549    pub type_: ResponseAdvisorResultType,
1550    #[serde(
1551        default,
1552        deserialize_with = "present_nullable",
1553        skip_serializing_if = "Option::is_none"
1554    )]
1555    pub stop_reason: Option<Option<String>>,
1556    pub text: String,
1557    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1558    pub rest: Rest,
1559}
1560
1561#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1562#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1563#[derive(gproxy_protocol_macros::DeclaredFields)]
1564pub enum ResponseAdvisorRedactedResultType {
1565    #[serde(rename = "advisor_redacted_result")]
1566    Tag,
1567}
1568
1569#[derive(
1570    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1571)]
1572#[serde(rename_all = "snake_case")]
1573#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1574#[derive(gproxy_protocol_macros::DeclaredFields)]
1575pub struct ResponseAdvisorRedactedResult {
1576    #[serde(rename = "type")]
1577    pub type_: ResponseAdvisorRedactedResultType,
1578    pub encrypted_content: String,
1579    #[serde(
1580        default,
1581        deserialize_with = "present_nullable",
1582        skip_serializing_if = "Option::is_none"
1583    )]
1584    pub stop_reason: Option<Option<String>>,
1585    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1586    pub rest: Rest,
1587}
1588
1589#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1590#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1591#[derive(gproxy_protocol_macros::DeclaredFields)]
1592pub enum ResponseCodeExecutionToolResultBlockType {
1593    #[serde(rename = "code_execution_tool_result")]
1594    Tag,
1595}
1596
1597#[derive(
1598    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1599)]
1600#[serde(rename_all = "snake_case")]
1601#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1602#[derive(gproxy_protocol_macros::DeclaredFields)]
1603pub struct ResponseCodeExecutionToolResultBlock {
1604    #[serde(rename = "type")]
1605    pub type_: ResponseCodeExecutionToolResultBlockType,
1606    pub content: content::CodeExecutionResultContent,
1607    pub tool_use_id: String,
1608    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1609    pub rest: Rest,
1610}
1611
1612#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1613#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1614#[derive(gproxy_protocol_macros::DeclaredFields)]
1615pub enum ResponseBashCodeExecutionToolResultBlockType {
1616    #[serde(rename = "bash_code_execution_tool_result")]
1617    Tag,
1618}
1619
1620#[derive(
1621    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1622)]
1623#[serde(rename_all = "snake_case")]
1624#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1625#[derive(gproxy_protocol_macros::DeclaredFields)]
1626pub struct ResponseBashCodeExecutionToolResultBlock {
1627    #[serde(rename = "type")]
1628    pub type_: ResponseBashCodeExecutionToolResultBlockType,
1629    pub content: content::BashCodeExecutionResultContent,
1630    pub tool_use_id: String,
1631    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1632    pub rest: Rest,
1633}
1634
1635#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1636#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1637#[derive(gproxy_protocol_macros::DeclaredFields)]
1638pub enum ResponseTextEditorCodeExecutionToolResultBlockType {
1639    #[serde(rename = "text_editor_code_execution_tool_result")]
1640    Tag,
1641}
1642
1643#[derive(
1644    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1645)]
1646#[serde(rename_all = "snake_case")]
1647#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1648#[derive(gproxy_protocol_macros::DeclaredFields)]
1649pub struct ResponseTextEditorCodeExecutionToolResultBlock {
1650    #[serde(rename = "type")]
1651    pub type_: ResponseTextEditorCodeExecutionToolResultBlockType,
1652    pub content: ResponseTextEditorResultContent,
1653    pub tool_use_id: String,
1654    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1655    pub rest: Rest,
1656}
1657
1658#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1659#[serde(untagged)]
1660#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1661#[derive(gproxy_protocol_macros::DeclaredFields)]
1662pub enum ResponseTextEditorResultContent {
1663    Error(ResponseTextEditorError),
1664    View(ResponseTextEditorViewResult),
1665    Create(content::TextEditorCreateResult),
1666    Replace(ResponseTextEditorReplaceResult),
1667}
1668
1669#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1670#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1671#[derive(gproxy_protocol_macros::DeclaredFields)]
1672pub enum ResponseTextEditorErrorType {
1673    #[serde(rename = "text_editor_code_execution_tool_result_error")]
1674    Tag,
1675}
1676
1677#[derive(
1678    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1679)]
1680#[serde(rename_all = "snake_case")]
1681#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1682#[derive(gproxy_protocol_macros::DeclaredFields)]
1683pub struct ResponseTextEditorError {
1684    #[serde(rename = "type")]
1685    pub type_: ResponseTextEditorErrorType,
1686    pub error_code: content::TextEditorErrorCode,
1687    #[serde(
1688        default,
1689        deserialize_with = "present_nullable",
1690        skip_serializing_if = "Option::is_none"
1691    )]
1692    pub error_message: Option<Option<String>>,
1693    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1694    pub rest: Rest,
1695}
1696
1697#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1698#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1699#[derive(gproxy_protocol_macros::DeclaredFields)]
1700pub enum ResponseTextEditorViewResultType {
1701    #[serde(rename = "text_editor_code_execution_view_result")]
1702    Tag,
1703}
1704
1705#[derive(
1706    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1707)]
1708#[serde(rename_all = "snake_case")]
1709#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1710#[derive(gproxy_protocol_macros::DeclaredFields)]
1711pub struct ResponseTextEditorViewResult {
1712    #[serde(rename = "type")]
1713    pub type_: ResponseTextEditorViewResultType,
1714    pub content: String,
1715    pub file_type: content::TextEditorFileType,
1716    #[serde(
1717        default,
1718        deserialize_with = "present_nullable",
1719        skip_serializing_if = "Option::is_none"
1720    )]
1721    pub num_lines: Option<Option<i64>>,
1722    #[serde(
1723        default,
1724        deserialize_with = "present_nullable",
1725        skip_serializing_if = "Option::is_none"
1726    )]
1727    pub start_line: Option<Option<i64>>,
1728    #[serde(
1729        default,
1730        deserialize_with = "present_nullable",
1731        skip_serializing_if = "Option::is_none"
1732    )]
1733    pub total_lines: Option<Option<i64>>,
1734    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1735    pub rest: Rest,
1736}
1737
1738#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1739#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1740#[derive(gproxy_protocol_macros::DeclaredFields)]
1741pub enum ResponseTextEditorReplaceResultType {
1742    #[serde(rename = "text_editor_code_execution_str_replace_result")]
1743    Tag,
1744}
1745
1746#[derive(
1747    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1748)]
1749#[serde(rename_all = "snake_case")]
1750#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1751#[derive(gproxy_protocol_macros::DeclaredFields)]
1752pub struct ResponseTextEditorReplaceResult {
1753    #[serde(rename = "type")]
1754    pub type_: ResponseTextEditorReplaceResultType,
1755    #[serde(
1756        default,
1757        deserialize_with = "present_nullable",
1758        skip_serializing_if = "Option::is_none"
1759    )]
1760    pub lines: Option<Option<Vec<String>>>,
1761    #[serde(
1762        default,
1763        deserialize_with = "present_nullable",
1764        skip_serializing_if = "Option::is_none"
1765    )]
1766    pub new_lines: Option<Option<i64>>,
1767    #[serde(
1768        default,
1769        deserialize_with = "present_nullable",
1770        skip_serializing_if = "Option::is_none"
1771    )]
1772    pub new_start: Option<Option<i64>>,
1773    #[serde(
1774        default,
1775        deserialize_with = "present_nullable",
1776        skip_serializing_if = "Option::is_none"
1777    )]
1778    pub old_lines: Option<Option<i64>>,
1779    #[serde(
1780        default,
1781        deserialize_with = "present_nullable",
1782        skip_serializing_if = "Option::is_none"
1783    )]
1784    pub old_start: Option<Option<i64>>,
1785    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1786    pub rest: Rest,
1787}
1788
1789#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1790#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1791#[derive(gproxy_protocol_macros::DeclaredFields)]
1792pub enum ResponseToolSearchToolResultBlockType {
1793    #[serde(rename = "tool_search_tool_result")]
1794    Tag,
1795}
1796
1797#[derive(
1798    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1799)]
1800#[serde(rename_all = "snake_case")]
1801#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1802#[derive(gproxy_protocol_macros::DeclaredFields)]
1803pub struct ResponseToolSearchToolResultBlock {
1804    #[serde(rename = "type")]
1805    pub type_: ResponseToolSearchToolResultBlockType,
1806    pub content: ResponseToolSearchResultContent,
1807    pub tool_use_id: String,
1808    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1809    pub rest: Rest,
1810}
1811
1812#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1813#[serde(untagged)]
1814#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1815#[derive(gproxy_protocol_macros::DeclaredFields)]
1816pub enum ResponseToolSearchResultContent {
1817    Error(ResponseToolSearchError),
1818    Search(ResponseToolSearchResults),
1819}
1820
1821#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1822#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1823#[derive(gproxy_protocol_macros::DeclaredFields)]
1824pub enum ResponseToolSearchErrorType {
1825    #[serde(rename = "tool_search_tool_result_error")]
1826    Tag,
1827}
1828
1829#[derive(
1830    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1831)]
1832#[serde(rename_all = "snake_case")]
1833#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1834#[derive(gproxy_protocol_macros::DeclaredFields)]
1835pub struct ResponseToolSearchError {
1836    #[serde(rename = "type")]
1837    pub type_: ResponseToolSearchErrorType,
1838    pub error_code: content::ToolSearchErrorCode,
1839    #[serde(
1840        default,
1841        deserialize_with = "present_nullable",
1842        skip_serializing_if = "Option::is_none"
1843    )]
1844    pub error_message: Option<Option<String>>,
1845    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1846    pub rest: Rest,
1847}
1848
1849#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1850#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1851#[derive(gproxy_protocol_macros::DeclaredFields)]
1852pub enum ResponseToolSearchResultsType {
1853    #[serde(rename = "tool_search_tool_search_result")]
1854    Tag,
1855}
1856
1857#[derive(
1858    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1859)]
1860#[serde(rename_all = "snake_case")]
1861#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1862#[derive(gproxy_protocol_macros::DeclaredFields)]
1863pub struct ResponseToolSearchResults {
1864    #[serde(rename = "type")]
1865    pub type_: ResponseToolSearchResultsType,
1866    pub tool_references: Vec<ResponseToolReferenceBlock>,
1867    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1868    pub rest: Rest,
1869}
1870
1871#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1872#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1873#[derive(gproxy_protocol_macros::DeclaredFields)]
1874pub enum ResponseToolReferenceBlockType {
1875    #[serde(rename = "tool_reference")]
1876    Tag,
1877}
1878
1879#[derive(
1880    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1881)]
1882#[serde(rename_all = "snake_case")]
1883#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1884#[derive(gproxy_protocol_macros::DeclaredFields)]
1885pub struct ResponseToolReferenceBlock {
1886    #[serde(rename = "type")]
1887    pub type_: ResponseToolReferenceBlockType,
1888    pub tool_name: String,
1889    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1890    pub rest: Rest,
1891}
1892
1893#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1894#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1895#[derive(gproxy_protocol_macros::DeclaredFields)]
1896pub enum ResponseMcpToolUseBlockType {
1897    #[serde(rename = "mcp_tool_use")]
1898    Tag,
1899}
1900
1901#[derive(
1902    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1903)]
1904#[serde(rename_all = "snake_case")]
1905#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1906#[derive(gproxy_protocol_macros::DeclaredFields)]
1907pub struct ResponseMcpToolUseBlock {
1908    #[serde(rename = "type")]
1909    pub type_: ResponseMcpToolUseBlockType,
1910    pub id: String,
1911    pub input: serde_json::Map<String, serde_json::Value>,
1912    pub name: String,
1913    pub server_name: String,
1914    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1915    pub rest: Rest,
1916}
1917
1918#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1919#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1920#[derive(gproxy_protocol_macros::DeclaredFields)]
1921pub enum ResponseMcpToolResultBlockType {
1922    #[serde(rename = "mcp_tool_result")]
1923    Tag,
1924}
1925
1926#[derive(
1927    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1928)]
1929#[serde(rename_all = "snake_case")]
1930#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1931#[derive(gproxy_protocol_macros::DeclaredFields)]
1932pub struct ResponseMcpToolResultBlock {
1933    #[serde(rename = "type")]
1934    pub type_: ResponseMcpToolResultBlockType,
1935    pub content: ResponseMcpResultContent,
1936    pub is_error: bool,
1937    pub tool_use_id: String,
1938    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1939    pub rest: Rest,
1940}
1941
1942#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1943#[serde(untagged)]
1944#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1945#[derive(gproxy_protocol_macros::DeclaredFields)]
1946pub enum ResponseMcpResultContent {
1947    Text(String),
1948    Blocks(Vec<ResponseTextBlock>),
1949}
1950
1951#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1952#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1953#[derive(gproxy_protocol_macros::DeclaredFields)]
1954pub enum ResponseContainerUploadBlockType {
1955    #[serde(rename = "container_upload")]
1956    Tag,
1957}
1958
1959#[derive(
1960    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1961)]
1962#[serde(rename_all = "snake_case")]
1963#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1964#[derive(gproxy_protocol_macros::DeclaredFields)]
1965pub struct ResponseContainerUploadBlock {
1966    #[serde(rename = "type")]
1967    pub type_: ResponseContainerUploadBlockType,
1968    pub file_id: String,
1969    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1970    pub rest: Rest,
1971}
1972
1973#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1974#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1975#[derive(gproxy_protocol_macros::DeclaredFields)]
1976pub enum ResponseCompactionBlockType {
1977    #[serde(rename = "compaction")]
1978    Tag,
1979}
1980
1981#[derive(
1982    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1983)]
1984#[serde(rename_all = "snake_case")]
1985#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1986#[derive(gproxy_protocol_macros::DeclaredFields)]
1987pub struct ResponseCompactionBlock {
1988    #[serde(
1989        default,
1990        deserialize_with = "present_nullable",
1991        skip_serializing_if = "Option::is_none"
1992    )]
1993    pub signature: Option<Option<String>>,
1994
1995    #[serde(rename = "type")]
1996    pub type_: ResponseCompactionBlockType,
1997    #[serde(
1998        default,
1999        deserialize_with = "present_nullable",
2000        skip_serializing_if = "Option::is_none"
2001    )]
2002    pub content: Option<Option<String>>,
2003    #[serde(
2004        default,
2005        deserialize_with = "present_nullable",
2006        skip_serializing_if = "Option::is_none"
2007    )]
2008    pub encrypted_content: Option<Option<String>>,
2009    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
2010    pub rest: Rest,
2011}
2012
2013#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
2014#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
2015#[derive(gproxy_protocol_macros::DeclaredFields)]
2016pub enum ResponseFallbackBlockType {
2017    #[serde(rename = "fallback")]
2018    Tag,
2019}
2020
2021#[derive(
2022    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
2023)]
2024#[serde(rename_all = "snake_case")]
2025#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
2026#[derive(gproxy_protocol_macros::DeclaredFields)]
2027pub struct ResponseFallbackBlock {
2028    #[serde(rename = "type")]
2029    pub type_: ResponseFallbackBlockType,
2030    pub from: content::FallbackInfo,
2031    pub to: content::FallbackInfo,
2032    pub trigger: FallbackRefusalTrigger,
2033    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
2034    pub rest: Rest,
2035}
2036
2037#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
2038#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
2039#[derive(gproxy_protocol_macros::DeclaredFields)]
2040pub enum FallbackRefusalTriggerType {
2041    #[serde(rename = "refusal")]
2042    Tag,
2043}
2044
2045#[derive(
2046    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
2047)]
2048#[serde(rename_all = "snake_case")]
2049#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
2050#[derive(gproxy_protocol_macros::DeclaredFields)]
2051pub struct FallbackRefusalTrigger {
2052    #[serde(rename = "type")]
2053    pub type_: FallbackRefusalTriggerType,
2054    #[serde(
2055        default,
2056        deserialize_with = "present_nullable",
2057        skip_serializing_if = "Option::is_none"
2058    )]
2059    pub category: Option<Option<RefusalCategory>>,
2060    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
2061    pub rest: Rest,
2062}
2063
2064#[derive(
2065    Debug,
2066    Clone,
2067    Copy,
2068    PartialEq,
2069    Eq,
2070    Serialize,
2071    Deserialize,
2072    gproxy_protocol_macros::DeclaredFields,
2073)]
2074#[serde(rename_all = "snake_case")]
2075#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
2076pub enum CompactionConfigType {
2077    Summarize,
2078}
2079
2080#[derive(
2081    Debug,
2082    Clone,
2083    PartialEq,
2084    Eq,
2085    Serialize,
2086    Deserialize,
2087    gproxy_protocol_macros::WireBuilder,
2088    gproxy_protocol_macros::DeclaredFields,
2089)]
2090#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
2091pub struct CompactionConfig {
2092    #[serde(rename = "type")]
2093    pub type_: CompactionConfigType,
2094    #[serde(skip_serializing_if = "Option::is_none")]
2095    pub instructions: Option<String>,
2096    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
2097    pub rest: Rest,
2098}
2099
2100#[derive(
2101    Debug,
2102    Clone,
2103    PartialEq,
2104    Eq,
2105    Serialize,
2106    Deserialize,
2107    gproxy_protocol_macros::WireBuilder,
2108    gproxy_protocol_macros::DeclaredFields,
2109)]
2110#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
2111pub struct InputTransformation {
2112    #[serde(rename = "type")]
2113    pub type_: InputTransformationType,
2114    pub path: String,
2115    pub reason: ThinkingBindingMismatchReason,
2116    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
2117    pub rest: Rest,
2118}
2119
2120#[derive(
2121    Debug,
2122    Clone,
2123    Copy,
2124    PartialEq,
2125    Eq,
2126    Serialize,
2127    Deserialize,
2128    gproxy_protocol_macros::DeclaredFields,
2129)]
2130#[serde(rename_all = "snake_case")]
2131#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
2132pub enum InputTransformationType {
2133    ThinkingDropped,
2134    ThinkingMismatchAllowed,
2135    #[serde(other)]
2136    Unknown,
2137}
2138
2139#[derive(
2140    Debug,
2141    Clone,
2142    Copy,
2143    PartialEq,
2144    Eq,
2145    Serialize,
2146    Deserialize,
2147    gproxy_protocol_macros::DeclaredFields,
2148)]
2149#[serde(rename_all = "snake_case")]
2150#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
2151pub enum ThinkingBindingMismatchReason {
2152    ModelBindingMismatch,
2153    PrefixBindingMismatch,
2154    OrganizationBindingMismatch,
2155    EndUserBindingMismatch,
2156    #[serde(other)]
2157    Unknown,
2158}