gproxy_protocol/wire/claude/
content.rs

1use serde::{Deserialize, Serialize};
2use serde_json::Value;
3
4use crate::Rest;
5
6fn present_value<'de, D>(deserializer: D) -> Result<Option<Value>, D::Error>
7where
8    D: serde::Deserializer<'de>,
9{
10    Value::deserialize(deserializer).map(Some)
11}
12
13fn present_nullable_string<'de, D>(deserializer: D) -> Result<Option<Option<String>>, D::Error>
14where
15    D: serde::Deserializer<'de>,
16{
17    Option::<String>::deserialize(deserializer).map(Some)
18}
19
20#[derive(
21    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
22)]
23#[serde(rename_all = "snake_case")]
24#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
25#[derive(gproxy_protocol_macros::DeclaredFields)]
26pub struct Message {
27    #[serde(skip_serializing_if = "Option::is_none")]
28    pub clear_at: Option<SystemMessageClearAt>,
29    #[serde(skip_serializing_if = "Option::is_none")]
30    pub output_config: Option<SystemMessageOutputConfig>,
31
32    pub role: Role,
33    pub content: MessageContent,
34    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
35    pub rest: Rest,
36}
37
38#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
39#[serde(rename_all = "snake_case")]
40#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
41#[derive(gproxy_protocol_macros::DeclaredFields)]
42pub enum Role {
43    User,
44    Assistant,
45    System,
46}
47
48#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
49#[serde(untagged)]
50#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
51#[derive(gproxy_protocol_macros::DeclaredFields)]
52pub enum MessageContent {
53    Text(String),
54    Blocks(Vec<ContentBlock>),
55}
56
57#[allow(clippy::large_enum_variant)]
58#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
59#[serde(untagged)]
60#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
61#[derive(gproxy_protocol_macros::DeclaredFields)]
62pub enum ContentBlock {
63    #[serde(rename = "text")]
64    Text(TextBlock),
65    #[serde(rename = "image")]
66    Image(ImageBlock),
67    #[serde(rename = "document")]
68    Document(DocumentBlock),
69    #[serde(rename = "thinking")]
70    Thinking(ThinkingBlock),
71    #[serde(rename = "redacted_thinking")]
72    RedactedThinking(RedactedThinkingBlock),
73    #[serde(rename = "tool_use")]
74    ToolUse(ToolUseBlock),
75    #[serde(rename = "tool_result")]
76    ToolResult(ToolResultBlock),
77    #[serde(rename = "server_tool_use")]
78    ServerToolUse(ServerToolUseBlock),
79    #[serde(rename = "search_result")]
80    SearchResult(SearchResultBlock),
81    WebSearchToolResult(WebSearchToolResultBlock),
82    WebFetchToolResult(WebFetchToolResultBlock),
83    AdvisorToolResult(AdvisorToolResultBlock),
84    CodeExecutionToolResult(CodeExecutionToolResultBlock),
85    BashCodeExecutionToolResult(BashCodeExecutionToolResultBlock),
86    TextEditorCodeExecutionToolResult(TextEditorCodeExecutionToolResultBlock),
87    ToolSearchToolResult(ToolSearchToolResultBlock),
88    McpToolListing(McpToolListingBlock),
89    McpToolUse(McpToolUseBlock),
90    McpToolResult(McpToolResultBlock),
91    ContainerUpload(ContainerUploadBlock),
92    Compaction(CompactionBlock),
93    MidConversationSystem(MidConversationSystemBlock),
94    ToolAddition(ToolAdditionBlock),
95    ToolRemoval(ToolRemovalBlock),
96    Fallback(FallbackBlock),
97}
98
99#[derive(
100    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
101)]
102#[serde(rename_all = "snake_case")]
103#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
104#[derive(gproxy_protocol_macros::DeclaredFields)]
105pub struct CacheControl {
106    #[serde(rename = "type")]
107    pub type_: CacheControlType,
108    #[serde(skip_serializing_if = "Option::is_none")]
109    pub ttl: Option<CacheTtl>,
110    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
111    pub rest: Rest,
112}
113#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
114#[serde(rename_all = "snake_case")]
115#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
116#[derive(gproxy_protocol_macros::DeclaredFields)]
117pub enum CacheControlType {
118    Ephemeral,
119}
120#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
121#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
122#[derive(gproxy_protocol_macros::DeclaredFields)]
123pub enum CacheTtl {
124    #[serde(rename = "5m")]
125    FiveMinutes,
126    #[serde(rename = "1h")]
127    OneHour,
128}
129
130#[derive(
131    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
132)]
133#[serde(rename_all = "snake_case")]
134#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
135#[derive(gproxy_protocol_macros::DeclaredFields)]
136pub struct TextBlock {
137    #[serde(rename = "type")]
138    pub type_: TextBlockType,
139    pub text: String,
140    #[serde(skip_serializing_if = "Option::is_none")]
141    pub cache_control: Option<CacheControl>,
142    #[serde(skip_serializing_if = "Option::is_none")]
143    pub citations: Option<Vec<TextCitation>>,
144    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
145    pub rest: Rest,
146}
147
148#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
149#[serde(tag = "type")]
150#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
151#[derive(gproxy_protocol_macros::DeclaredFields)]
152pub enum TextCitation {
153    #[serde(rename = "char_location")]
154    Char(CharCitation),
155    #[serde(rename = "page_location")]
156    Page(PageCitation),
157    #[serde(rename = "content_block_location")]
158    ContentBlock(ContentBlockCitation),
159    #[serde(rename = "web_search_result_location")]
160    Web(WebCitation),
161    #[serde(rename = "search_result_location")]
162    Search(SearchCitation),
163}
164#[derive(
165    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
166)]
167#[serde(rename_all = "snake_case")]
168#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
169#[derive(gproxy_protocol_macros::DeclaredFields)]
170pub struct CharCitation {
171    pub cited_text: String,
172    pub document_index: i64,
173    pub document_title: String,
174    pub end_char_index: i64,
175    pub start_char_index: i64,
176    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
177    pub rest: Rest,
178}
179#[derive(
180    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
181)]
182#[serde(rename_all = "snake_case")]
183#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
184#[derive(gproxy_protocol_macros::DeclaredFields)]
185pub struct PageCitation {
186    pub cited_text: String,
187    pub document_index: i64,
188    pub document_title: String,
189    pub end_page_number: i64,
190    pub start_page_number: i64,
191    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
192    pub rest: Rest,
193}
194#[derive(
195    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
196)]
197#[serde(rename_all = "snake_case")]
198#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
199#[derive(gproxy_protocol_macros::DeclaredFields)]
200pub struct ContentBlockCitation {
201    pub cited_text: String,
202    pub document_index: i64,
203    pub document_title: String,
204    pub end_block_index: i64,
205    pub start_block_index: i64,
206    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
207    pub rest: Rest,
208}
209#[derive(
210    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
211)]
212#[serde(rename_all = "snake_case")]
213#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
214#[derive(gproxy_protocol_macros::DeclaredFields)]
215pub struct WebCitation {
216    pub cited_text: String,
217    pub encrypted_index: String,
218    pub title: String,
219    pub url: String,
220    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
221    pub rest: Rest,
222}
223#[derive(
224    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
225)]
226#[serde(rename_all = "snake_case")]
227#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
228#[derive(gproxy_protocol_macros::DeclaredFields)]
229pub struct SearchCitation {
230    pub cited_text: String,
231    pub end_block_index: i64,
232    pub search_result_index: i64,
233    pub source: String,
234    pub start_block_index: i64,
235    pub title: String,
236    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
237    pub rest: Rest,
238}
239
240#[derive(
241    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
242)]
243#[serde(rename_all = "snake_case")]
244#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
245#[derive(gproxy_protocol_macros::DeclaredFields)]
246pub struct ImageBlock {
247    #[serde(rename = "type")]
248    pub type_: ImageBlockType,
249    pub source: ImageSource,
250    #[serde(skip_serializing_if = "Option::is_none")]
251    pub cache_control: Option<CacheControl>,
252    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
253    pub rest: Rest,
254}
255#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
256#[serde(tag = "type")]
257#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
258#[derive(gproxy_protocol_macros::DeclaredFields)]
259pub enum ImageSource {
260    #[serde(rename = "base64")]
261    Base64(Base64Source),
262    #[serde(rename = "url")]
263    Url(UrlSource),
264    #[serde(rename = "file")]
265    File(FileSource),
266}
267#[derive(
268    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
269)]
270#[serde(rename_all = "snake_case")]
271#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
272#[derive(gproxy_protocol_macros::DeclaredFields)]
273pub struct Base64Source {
274    pub data: String,
275    pub media_type: ImageMediaType,
276    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
277    pub rest: Rest,
278}
279#[derive(
280    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
281)]
282#[serde(rename_all = "snake_case")]
283#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
284#[derive(gproxy_protocol_macros::DeclaredFields)]
285pub struct UrlSource {
286    pub url: String,
287    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
288    pub rest: Rest,
289}
290#[derive(
291    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
292)]
293#[serde(rename_all = "snake_case")]
294#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
295#[derive(gproxy_protocol_macros::DeclaredFields)]
296pub struct FileSource {
297    pub file_id: String,
298    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
299    pub rest: Rest,
300}
301#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
302#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
303#[derive(gproxy_protocol_macros::DeclaredFields)]
304pub enum ImageMediaType {
305    #[serde(rename = "image/jpeg")]
306    Jpeg,
307    #[serde(rename = "image/png")]
308    Png,
309    #[serde(rename = "image/gif")]
310    Gif,
311    #[serde(rename = "image/webp")]
312    Webp,
313}
314
315#[derive(
316    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
317)]
318#[serde(rename_all = "snake_case")]
319#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
320#[derive(gproxy_protocol_macros::DeclaredFields)]
321pub struct DocumentBlock {
322    #[serde(rename = "type")]
323    pub type_: DocumentBlockType,
324    pub source: DocumentSource,
325    #[serde(skip_serializing_if = "Option::is_none")]
326    pub cache_control: Option<CacheControl>,
327    #[serde(skip_serializing_if = "Option::is_none")]
328    pub citations: Option<CitationsConfig>,
329    #[serde(skip_serializing_if = "Option::is_none")]
330    pub context: Option<String>,
331    #[serde(skip_serializing_if = "Option::is_none")]
332    pub title: Option<String>,
333    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
334    pub rest: Rest,
335}
336#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
337#[serde(tag = "type")]
338#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
339#[derive(gproxy_protocol_macros::DeclaredFields)]
340pub enum DocumentSource {
341    #[serde(rename = "base64")]
342    Base64(PdfBase64Source),
343    #[serde(rename = "text")]
344    Text(PlainTextSource),
345    #[serde(rename = "url")]
346    Url(UrlSource),
347    #[serde(rename = "file")]
348    File(FileSource),
349    #[serde(rename = "content")]
350    Content(ContentSource),
351}
352#[derive(
353    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
354)]
355#[serde(rename_all = "snake_case")]
356#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
357#[derive(gproxy_protocol_macros::DeclaredFields)]
358pub struct PdfBase64Source {
359    pub data: String,
360    pub media_type: PdfMediaType,
361    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
362    pub rest: Rest,
363}
364#[derive(
365    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
366)]
367#[serde(rename_all = "snake_case")]
368#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
369#[derive(gproxy_protocol_macros::DeclaredFields)]
370pub struct PlainTextSource {
371    pub data: String,
372    pub media_type: TextMediaType,
373    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
374    pub rest: Rest,
375}
376#[derive(
377    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
378)]
379#[serde(rename_all = "snake_case")]
380#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
381#[derive(gproxy_protocol_macros::DeclaredFields)]
382pub struct ContentSource {
383    pub content: DocumentContent,
384    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
385    pub rest: Rest,
386}
387#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
388#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
389#[derive(gproxy_protocol_macros::DeclaredFields)]
390pub enum PdfMediaType {
391    #[serde(rename = "application/pdf")]
392    Pdf,
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 TextMediaType {
398    #[serde(rename = "text/plain")]
399    Plain,
400}
401#[derive(
402    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
403)]
404#[serde(rename_all = "snake_case")]
405#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
406#[derive(gproxy_protocol_macros::DeclaredFields)]
407pub struct CitationsConfig {
408    #[serde(skip_serializing_if = "Option::is_none")]
409    pub enabled: Option<bool>,
410    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
411    pub rest: Rest,
412}
413
414#[derive(
415    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
416)]
417#[serde(rename_all = "snake_case")]
418#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
419#[derive(gproxy_protocol_macros::DeclaredFields)]
420pub struct ThinkingBlock {
421    #[serde(rename = "type")]
422    pub type_: ThinkingBlockType,
423    pub signature: String,
424    pub thinking: String,
425    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
426    pub rest: Rest,
427}
428#[derive(
429    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
430)]
431#[serde(rename_all = "snake_case")]
432#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
433#[derive(gproxy_protocol_macros::DeclaredFields)]
434pub struct RedactedThinkingBlock {
435    #[serde(rename = "type")]
436    pub type_: RedactedThinkingBlockType,
437    pub data: String,
438    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
439    pub rest: Rest,
440}
441#[derive(
442    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
443)]
444#[serde(rename_all = "snake_case")]
445#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
446#[derive(gproxy_protocol_macros::DeclaredFields)]
447pub struct ToolUseBlock {
448    #[serde(skip_serializing_if = "Option::is_none")]
449    pub toolset_name: Option<String>,
450
451    #[serde(rename = "type")]
452    pub type_: ToolUseBlockType,
453    pub id: String,
454    pub input: Value,
455    pub name: String,
456    #[serde(skip_serializing_if = "Option::is_none")]
457    pub caller: Option<ToolCaller>,
458    #[serde(skip_serializing_if = "Option::is_none")]
459    pub cache_control: Option<CacheControl>,
460    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
461    pub rest: Rest,
462}
463#[derive(
464    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
465)]
466#[serde(rename_all = "snake_case")]
467#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
468#[derive(gproxy_protocol_macros::DeclaredFields)]
469pub struct ToolResultBlock {
470    #[serde(skip_serializing_if = "Option::is_none")]
471    pub toolset_name: Option<String>,
472
473    #[serde(rename = "type")]
474    pub type_: ToolResultBlockType,
475    pub tool_use_id: String,
476    #[serde(skip_serializing_if = "Option::is_none")]
477    pub content: Option<ToolResultContent>,
478    #[serde(skip_serializing_if = "Option::is_none")]
479    pub is_error: Option<bool>,
480    #[serde(skip_serializing_if = "Option::is_none")]
481    pub cache_control: Option<CacheControl>,
482    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
483    pub rest: Rest,
484}
485#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
486#[serde(untagged)]
487#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
488#[derive(gproxy_protocol_macros::DeclaredFields)]
489pub enum ToolResultContent {
490    Text(String),
491    Blocks(Vec<ToolResultContentBlock>),
492}
493#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
494#[serde(untagged)]
495#[derive(gproxy_protocol_macros::DeclaredFields)]
496pub enum ToolResultContentBlock {
497    BrowserState(BrowserStateBlock),
498    Text(TextBlock),
499    Image(ImageBlock),
500    SearchResult(SearchResultBlock),
501    Document(DocumentBlock),
502    ToolReference(ToolReferenceBlock),
503}
504#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
505#[serde(untagged)]
506#[derive(gproxy_protocol_macros::DeclaredFields)]
507pub enum DocumentContent {
508    Text(String),
509    Blocks(Vec<DocumentContentBlock>),
510}
511#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
512#[serde(untagged)]
513#[derive(gproxy_protocol_macros::DeclaredFields)]
514pub enum DocumentContentBlock {
515    Text(TextBlock),
516    Image(ImageBlock),
517}
518#[derive(
519    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
520)]
521#[serde(rename_all = "snake_case")]
522#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
523#[derive(gproxy_protocol_macros::DeclaredFields)]
524pub struct ServerToolUseBlock {
525    #[serde(rename = "type")]
526    pub type_: ServerToolUseBlockType,
527    pub id: String,
528    pub input: Value,
529    pub name: ServerToolName,
530    #[serde(skip_serializing_if = "Option::is_none")]
531    pub caller: Option<ToolCaller>,
532    #[serde(skip_serializing_if = "Option::is_none")]
533    pub cache_control: Option<CacheControl>,
534    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
535    pub rest: Rest,
536}
537#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
538#[serde(rename_all = "snake_case")]
539#[derive(gproxy_protocol_macros::DeclaredFields)]
540pub enum ServerToolName {
541    Advisor,
542    WebSearch,
543    WebFetch,
544    CodeExecution,
545    BashCodeExecution,
546    TextEditorCodeExecution,
547    ToolSearchToolRegex,
548    ToolSearchToolBm25,
549}
550#[derive(
551    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
552)]
553#[serde(rename_all = "snake_case")]
554#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
555#[derive(gproxy_protocol_macros::DeclaredFields)]
556pub struct SearchResultBlock {
557    #[serde(rename = "type")]
558    pub type_: SearchResultBlockType,
559    pub content: Vec<TextBlock>,
560    pub source: String,
561    pub title: String,
562    #[serde(skip_serializing_if = "Option::is_none")]
563    pub cache_control: Option<CacheControl>,
564    #[serde(skip_serializing_if = "Option::is_none")]
565    pub citations: Option<CitationsConfig>,
566    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
567    pub rest: Rest,
568}
569
570#[derive(
571    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
572)]
573#[serde(rename_all = "snake_case")]
574#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
575#[derive(gproxy_protocol_macros::DeclaredFields)]
576pub struct ToolReferenceBlock {
577    #[serde(rename = "type")]
578    pub type_: ToolReferenceBlockType,
579    pub tool_name: String,
580    #[serde(skip_serializing_if = "Option::is_none")]
581    pub cache_control: Option<CacheControl>,
582    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
583    pub rest: Rest,
584}
585
586#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
587#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
588#[derive(gproxy_protocol_macros::DeclaredFields)]
589pub enum WebSearchToolResultType {
590    #[serde(rename = "web_search_tool_result")]
591    Tag,
592}
593#[derive(
594    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
595)]
596#[serde(rename_all = "snake_case")]
597#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
598#[derive(gproxy_protocol_macros::DeclaredFields)]
599pub struct WebSearchToolResultBlock {
600    #[serde(rename = "type")]
601    pub type_: WebSearchToolResultType,
602    pub content: WebSearchResultContent,
603    pub tool_use_id: String,
604    #[serde(skip_serializing_if = "Option::is_none")]
605    pub cache_control: Option<CacheControl>,
606    #[serde(skip_serializing_if = "Option::is_none")]
607    pub caller: Option<ToolCaller>,
608    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
609    pub rest: Rest,
610}
611
612#[derive(
613    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
614)]
615#[serde(rename_all = "snake_case")]
616#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
617#[derive(gproxy_protocol_macros::DeclaredFields)]
618pub struct WebFetchToolResultBlock {
619    #[serde(rename = "type")]
620    pub type_: WebFetchToolResultType,
621    pub content: WebFetchResultContent,
622    pub tool_use_id: String,
623    #[serde(skip_serializing_if = "Option::is_none")]
624    pub cache_control: Option<CacheControl>,
625    #[serde(skip_serializing_if = "Option::is_none")]
626    pub caller: Option<ToolCaller>,
627    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
628    pub rest: Rest,
629}
630#[derive(
631    Debug,
632    Clone,
633    Copy,
634    PartialEq,
635    Eq,
636    Serialize,
637    Deserialize,
638    gproxy_protocol_macros::DeclaredFields,
639)]
640pub enum WebFetchToolResultType {
641    #[serde(rename = "web_fetch_tool_result")]
642    Tag,
643}
644
645#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
646#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
647#[derive(gproxy_protocol_macros::DeclaredFields)]
648pub enum AdvisorToolResultType {
649    #[serde(rename = "advisor_tool_result")]
650    Tag,
651}
652#[derive(
653    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
654)]
655#[serde(rename_all = "snake_case")]
656#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
657#[derive(gproxy_protocol_macros::DeclaredFields)]
658pub struct AdvisorToolResultBlock {
659    #[serde(rename = "type")]
660    pub type_: AdvisorToolResultType,
661    pub content: AdvisorResultContent,
662    pub tool_use_id: String,
663    #[serde(skip_serializing_if = "Option::is_none")]
664    pub cache_control: Option<CacheControl>,
665    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
666    pub rest: Rest,
667}
668
669#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
670#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
671#[derive(gproxy_protocol_macros::DeclaredFields)]
672pub enum CodeExecutionToolResultType {
673    #[serde(rename = "code_execution_tool_result")]
674    Tag,
675}
676#[derive(
677    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
678)]
679#[serde(rename_all = "snake_case")]
680#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
681#[derive(gproxy_protocol_macros::DeclaredFields)]
682pub struct CodeExecutionToolResultBlock {
683    #[serde(rename = "type")]
684    pub type_: CodeExecutionToolResultType,
685    pub content: CodeExecutionResultContent,
686    pub tool_use_id: String,
687    #[serde(skip_serializing_if = "Option::is_none")]
688    pub cache_control: Option<CacheControl>,
689    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
690    pub rest: Rest,
691}
692
693#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
694#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
695#[derive(gproxy_protocol_macros::DeclaredFields)]
696pub enum BashCodeExecutionToolResultType {
697    #[serde(rename = "bash_code_execution_tool_result")]
698    Tag,
699}
700#[derive(
701    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
702)]
703#[serde(rename_all = "snake_case")]
704#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
705#[derive(gproxy_protocol_macros::DeclaredFields)]
706pub struct BashCodeExecutionToolResultBlock {
707    #[serde(rename = "type")]
708    pub type_: BashCodeExecutionToolResultType,
709    pub content: BashCodeExecutionResultContent,
710    pub tool_use_id: String,
711    #[serde(skip_serializing_if = "Option::is_none")]
712    pub cache_control: Option<CacheControl>,
713    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
714    pub rest: Rest,
715}
716
717#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
718#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
719#[derive(gproxy_protocol_macros::DeclaredFields)]
720pub enum TextEditorCodeExecutionToolResultType {
721    #[serde(rename = "text_editor_code_execution_tool_result")]
722    Tag,
723}
724#[derive(
725    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
726)]
727#[serde(rename_all = "snake_case")]
728#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
729#[derive(gproxy_protocol_macros::DeclaredFields)]
730pub struct TextEditorCodeExecutionToolResultBlock {
731    #[serde(rename = "type")]
732    pub type_: TextEditorCodeExecutionToolResultType,
733    pub content: TextEditorResultContent,
734    pub tool_use_id: String,
735    #[serde(skip_serializing_if = "Option::is_none")]
736    pub cache_control: Option<CacheControl>,
737    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
738    pub rest: Rest,
739}
740
741#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
742#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
743#[derive(gproxy_protocol_macros::DeclaredFields)]
744pub enum ToolSearchToolResultType {
745    #[serde(rename = "tool_search_tool_result")]
746    Tag,
747}
748#[derive(
749    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
750)]
751#[serde(rename_all = "snake_case")]
752#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
753#[derive(gproxy_protocol_macros::DeclaredFields)]
754pub struct ToolSearchToolResultBlock {
755    #[serde(rename = "type")]
756    pub type_: ToolSearchToolResultType,
757    pub content: ToolSearchResultContent,
758    pub tool_use_id: String,
759    #[serde(skip_serializing_if = "Option::is_none")]
760    pub cache_control: Option<CacheControl>,
761    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
762    pub rest: Rest,
763}
764
765#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
766#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
767#[derive(gproxy_protocol_macros::DeclaredFields)]
768pub enum McpToolUseType {
769    #[serde(rename = "mcp_tool_use")]
770    Tag,
771}
772#[derive(
773    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
774)]
775#[serde(rename_all = "snake_case")]
776#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
777#[derive(gproxy_protocol_macros::DeclaredFields)]
778pub struct McpToolUseBlock {
779    #[serde(rename = "type")]
780    pub type_: McpToolUseType,
781    pub id: String,
782    pub input: Value,
783    pub name: String,
784    pub server_name: String,
785    #[serde(skip_serializing_if = "Option::is_none")]
786    pub cache_control: Option<CacheControl>,
787    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
788    pub rest: Rest,
789}
790
791#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
792#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
793#[derive(gproxy_protocol_macros::DeclaredFields)]
794pub enum McpToolResultType {
795    #[serde(rename = "mcp_tool_result")]
796    Tag,
797}
798#[derive(
799    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
800)]
801#[serde(rename_all = "snake_case")]
802#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
803#[derive(gproxy_protocol_macros::DeclaredFields)]
804pub struct McpToolResultBlock {
805    #[serde(rename = "type")]
806    pub type_: McpToolResultType,
807    pub tool_use_id: String,
808    #[serde(skip_serializing_if = "Option::is_none")]
809    pub content: Option<McpResultContent>,
810    #[serde(skip_serializing_if = "Option::is_none")]
811    pub is_error: Option<bool>,
812    #[serde(skip_serializing_if = "Option::is_none")]
813    pub cache_control: Option<CacheControl>,
814    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
815    pub rest: Rest,
816}
817
818#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
819#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
820#[derive(gproxy_protocol_macros::DeclaredFields)]
821pub enum ContainerUploadType {
822    #[serde(rename = "container_upload")]
823    Tag,
824}
825#[derive(
826    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
827)]
828#[serde(rename_all = "snake_case")]
829#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
830#[derive(gproxy_protocol_macros::DeclaredFields)]
831pub struct ContainerUploadBlock {
832    #[serde(rename = "type")]
833    pub type_: ContainerUploadType,
834    pub file_id: String,
835    #[serde(skip_serializing_if = "Option::is_none")]
836    pub cache_control: Option<CacheControl>,
837    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
838    pub rest: Rest,
839}
840
841#[derive(
842    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
843)]
844#[serde(rename_all = "snake_case")]
845#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
846#[derive(gproxy_protocol_macros::DeclaredFields)]
847pub struct CompactionBlock {
848    #[serde(
849        default,
850        deserialize_with = "present_nullable_string",
851        skip_serializing_if = "Option::is_none"
852    )]
853    pub signature: Option<Option<String>>,
854
855    #[serde(rename = "type")]
856    pub type_: CompactionType,
857    #[serde(skip_serializing_if = "Option::is_none")]
858    pub cache_control: Option<CacheControl>,
859    #[serde(
860        default,
861        deserialize_with = "present_nullable_string",
862        skip_serializing_if = "Option::is_none"
863    )]
864    pub content: Option<Option<String>>,
865    #[serde(skip_serializing_if = "Option::is_none")]
866    pub encrypted_content: Option<String>,
867    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
868    pub rest: Rest,
869}
870#[derive(
871    Debug,
872    Clone,
873    Copy,
874    PartialEq,
875    Eq,
876    Serialize,
877    Deserialize,
878    gproxy_protocol_macros::DeclaredFields,
879)]
880pub enum CompactionType {
881    #[serde(rename = "compaction")]
882    Tag,
883}
884
885#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
886#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
887#[derive(gproxy_protocol_macros::DeclaredFields)]
888pub enum MidConversationSystemType {
889    #[serde(rename = "mid_conv_system")]
890    Tag,
891}
892#[derive(
893    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
894)]
895#[serde(rename_all = "snake_case")]
896#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
897#[derive(gproxy_protocol_macros::DeclaredFields)]
898pub struct MidConversationSystemBlock {
899    #[serde(rename = "type")]
900    pub type_: MidConversationSystemType,
901    pub content: Vec<MidConversationContent>,
902    #[serde(skip_serializing_if = "Option::is_none")]
903    pub cache_control: Option<CacheControl>,
904    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
905    pub rest: Rest,
906}
907
908#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
909#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
910#[derive(gproxy_protocol_macros::DeclaredFields)]
911pub enum ToolAdditionType {
912    #[serde(rename = "tool_addition")]
913    Tag,
914}
915#[derive(
916    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
917)]
918#[serde(rename_all = "snake_case")]
919#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
920#[derive(gproxy_protocol_macros::DeclaredFields)]
921pub struct ToolAdditionBlock {
922    #[serde(rename = "type")]
923    pub type_: ToolAdditionType,
924    pub tool: ToolAdditionReference,
925    #[serde(skip_serializing_if = "Option::is_none")]
926    pub cache_control: Option<CacheControl>,
927    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
928    pub rest: Rest,
929}
930
931#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
932#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
933#[derive(gproxy_protocol_macros::DeclaredFields)]
934pub enum ToolRemovalType {
935    #[serde(rename = "tool_removal")]
936    Tag,
937}
938#[derive(
939    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
940)]
941#[serde(rename_all = "snake_case")]
942#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
943#[derive(gproxy_protocol_macros::DeclaredFields)]
944pub struct ToolRemovalBlock {
945    #[serde(rename = "type")]
946    pub type_: ToolRemovalType,
947    pub tool: ToolChangeReference,
948    #[serde(skip_serializing_if = "Option::is_none")]
949    pub cache_control: Option<CacheControl>,
950    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
951    pub rest: Rest,
952}
953
954#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
955#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
956#[derive(gproxy_protocol_macros::DeclaredFields)]
957pub enum FallbackType {
958    #[serde(rename = "fallback")]
959    Tag,
960}
961#[derive(
962    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
963)]
964#[serde(rename_all = "snake_case")]
965#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
966#[derive(gproxy_protocol_macros::DeclaredFields)]
967pub struct FallbackBlock {
968    #[serde(rename = "type")]
969    pub type_: FallbackType,
970    pub from: FallbackInfo,
971    pub to: FallbackInfo,
972    #[serde(
973        default,
974        deserialize_with = "present_value",
975        skip_serializing_if = "Option::is_none"
976    )]
977    pub trigger: Option<Value>,
978    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
979    pub rest: Rest,
980}
981
982#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
983#[serde(untagged)]
984#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
985#[derive(gproxy_protocol_macros::DeclaredFields)]
986pub enum WebSearchResultContent {
987    Results(Vec<WebSearchResult>),
988    Error(WebSearchError),
989}
990macro_rules! single_tag_enum {
991    ($name:ident, $tag:literal) => {
992        #[derive(
993            Debug,
994            Clone,
995            Copy,
996            PartialEq,
997            Eq,
998            Serialize,
999            Deserialize,
1000            gproxy_protocol_macros::DeclaredFields,
1001        )]
1002        pub enum $name {
1003            #[serde(rename = $tag)]
1004            Tag,
1005        }
1006    };
1007}
1008single_tag_enum!(WebSearchResultType, "web_search_result");
1009single_tag_enum!(WebSearchErrorType, "web_search_tool_result_error");
1010single_tag_enum!(WebFetchResultType, "web_fetch_result");
1011single_tag_enum!(AdvisorErrorType, "advisor_tool_result_error");
1012single_tag_enum!(AdvisorResultType, "advisor_result");
1013single_tag_enum!(AdvisorRedactedResultType, "advisor_redacted_result");
1014single_tag_enum!(CodeExecutionErrorType, "code_execution_tool_result_error");
1015single_tag_enum!(CodeExecutionOutputType, "code_execution_output");
1016single_tag_enum!(CodeExecutionResultType, "code_execution_result");
1017single_tag_enum!(
1018    EncryptedCodeExecutionResultType,
1019    "encrypted_code_execution_result"
1020);
1021single_tag_enum!(
1022    BashCodeExecutionErrorType,
1023    "bash_code_execution_tool_result_error"
1024);
1025single_tag_enum!(BashCodeExecutionOutputType, "bash_code_execution_output");
1026single_tag_enum!(BashCodeExecutionResultType, "bash_code_execution_result");
1027single_tag_enum!(
1028    TextEditorErrorType,
1029    "text_editor_code_execution_tool_result_error"
1030);
1031single_tag_enum!(
1032    TextEditorViewResultType,
1033    "text_editor_code_execution_view_result"
1034);
1035single_tag_enum!(
1036    TextEditorCreateResultType,
1037    "text_editor_code_execution_create_result"
1038);
1039single_tag_enum!(
1040    TextEditorReplaceResultType,
1041    "text_editor_code_execution_str_replace_result"
1042);
1043single_tag_enum!(ToolSearchErrorType, "tool_search_tool_result_error");
1044single_tag_enum!(ToolSearchResultsType, "tool_search_tool_search_result");
1045#[derive(
1046    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1047)]
1048#[serde(rename_all = "snake_case")]
1049#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1050#[derive(gproxy_protocol_macros::DeclaredFields)]
1051pub struct WebSearchResult {
1052    #[serde(rename = "type")]
1053    pub type_: WebSearchResultType,
1054    pub encrypted_content: String,
1055    pub title: String,
1056    pub url: String,
1057    #[serde(skip_serializing_if = "Option::is_none")]
1058    pub page_age: Option<String>,
1059    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1060    pub rest: Rest,
1061}
1062#[derive(
1063    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1064)]
1065#[serde(rename_all = "snake_case")]
1066#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1067#[derive(gproxy_protocol_macros::DeclaredFields)]
1068pub struct WebSearchError {
1069    #[serde(rename = "type")]
1070    pub type_: WebSearchErrorType,
1071    pub error_code: WebSearchErrorCode,
1072    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1073    pub rest: Rest,
1074}
1075#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1076#[serde(rename_all = "snake_case")]
1077#[derive(gproxy_protocol_macros::DeclaredFields)]
1078pub enum WebSearchErrorCode {
1079    InvalidToolInput,
1080    Unavailable,
1081    MaxUsesExceeded,
1082    TooManyRequests,
1083    QueryTooLong,
1084    RequestTooLarge,
1085}
1086pub type ToolCaller = Caller;
1087#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1088#[serde(tag = "type")]
1089#[derive(gproxy_protocol_macros::DeclaredFields)]
1090pub enum Caller {
1091    #[serde(rename = "direct")]
1092    Direct(DirectCaller),
1093    #[serde(rename = "code_execution_20250825")]
1094    Server(ServerCaller),
1095    #[serde(rename = "code_execution_20260120")]
1096    Server20260120(ServerCaller20260120),
1097}
1098#[derive(
1099    Debug,
1100    Clone,
1101    PartialEq,
1102    Eq,
1103    Serialize,
1104    Deserialize,
1105    gproxy_protocol_macros::WireBuilder,
1106    gproxy_protocol_macros::DeclaredFields,
1107)]
1108pub struct DirectCaller {
1109    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1110    pub rest: Rest,
1111}
1112#[derive(
1113    Debug,
1114    Clone,
1115    PartialEq,
1116    Eq,
1117    Serialize,
1118    Deserialize,
1119    gproxy_protocol_macros::WireBuilder,
1120    gproxy_protocol_macros::DeclaredFields,
1121)]
1122pub struct ServerCaller {
1123    pub tool_id: String,
1124    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1125    pub rest: Rest,
1126}
1127#[derive(
1128    Debug,
1129    Clone,
1130    PartialEq,
1131    Eq,
1132    Serialize,
1133    Deserialize,
1134    gproxy_protocol_macros::WireBuilder,
1135    gproxy_protocol_macros::DeclaredFields,
1136)]
1137pub struct ServerCaller20260120 {
1138    pub tool_id: String,
1139    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1140    pub rest: Rest,
1141}
1142#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1143#[serde(untagged)]
1144#[derive(gproxy_protocol_macros::DeclaredFields)]
1145pub enum McpResultContent {
1146    Text(String),
1147    Blocks(Vec<TextBlock>),
1148}
1149
1150#[allow(clippy::large_enum_variant)]
1151#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1152#[serde(untagged)]
1153#[derive(gproxy_protocol_macros::DeclaredFields)]
1154pub enum WebFetchResultContent {
1155    Error(WebFetchError),
1156    Result(WebFetchResult),
1157}
1158#[derive(
1159    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1160)]
1161#[serde(rename_all = "snake_case")]
1162#[derive(gproxy_protocol_macros::DeclaredFields)]
1163pub struct WebFetchError {
1164    #[serde(rename = "type")]
1165    pub type_: WebFetchErrorType,
1166    pub error_code: WebFetchErrorCode,
1167    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1168    pub rest: Rest,
1169}
1170#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1171#[serde(rename_all = "snake_case")]
1172#[derive(gproxy_protocol_macros::DeclaredFields)]
1173pub enum WebFetchErrorType {
1174    WebFetchToolResultError,
1175}
1176#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1177#[serde(rename_all = "snake_case")]
1178#[derive(gproxy_protocol_macros::DeclaredFields)]
1179pub enum WebFetchErrorCode {
1180    InvalidToolInput,
1181    UrlTooLong,
1182    UrlNotAllowed,
1183    UrlNotInPriorContext,
1184    UrlNotAccessible,
1185    UnsupportedContentType,
1186    TooManyRequests,
1187    MaxUsesExceeded,
1188    Unavailable,
1189}
1190#[derive(
1191    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1192)]
1193#[serde(rename_all = "snake_case")]
1194#[derive(gproxy_protocol_macros::DeclaredFields)]
1195pub struct WebFetchResult {
1196    #[serde(rename = "type")]
1197    pub type_: WebFetchResultType,
1198    pub content: DocumentBlock,
1199    pub url: String,
1200    #[serde(skip_serializing_if = "Option::is_none")]
1201    pub retrieved_at: Option<String>,
1202    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1203    pub rest: Rest,
1204}
1205
1206#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1207#[serde(untagged)]
1208#[derive(gproxy_protocol_macros::DeclaredFields)]
1209pub enum AdvisorResultContent {
1210    Error(AdvisorError),
1211    Result(AdvisorResult),
1212    Redacted(AdvisorRedactedResult),
1213}
1214#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1215#[serde(rename_all = "snake_case")]
1216#[derive(gproxy_protocol_macros::DeclaredFields)]
1217pub enum AdvisorErrorCode {
1218    MaxUsesExceeded,
1219    PromptTooLong,
1220    TooManyRequests,
1221    Overloaded,
1222    Unavailable,
1223    ExecutionTimeExceeded,
1224    ModelNotFound,
1225}
1226#[derive(
1227    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1228)]
1229#[serde(rename_all = "snake_case")]
1230#[derive(gproxy_protocol_macros::DeclaredFields)]
1231pub struct AdvisorError {
1232    #[serde(rename = "type")]
1233    pub type_: AdvisorErrorType,
1234    pub error_code: AdvisorErrorCode,
1235    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1236    pub rest: Rest,
1237}
1238#[derive(
1239    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1240)]
1241#[serde(rename_all = "snake_case")]
1242#[derive(gproxy_protocol_macros::DeclaredFields)]
1243pub struct AdvisorResult {
1244    #[serde(rename = "type")]
1245    pub type_: AdvisorResultType,
1246    pub text: String,
1247    #[serde(skip_serializing_if = "Option::is_none")]
1248    pub stop_reason: Option<String>,
1249    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1250    pub rest: Rest,
1251}
1252#[derive(
1253    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1254)]
1255#[serde(rename_all = "snake_case")]
1256#[derive(gproxy_protocol_macros::DeclaredFields)]
1257pub struct AdvisorRedactedResult {
1258    #[serde(rename = "type")]
1259    pub type_: AdvisorRedactedResultType,
1260    pub encrypted_content: String,
1261    #[serde(skip_serializing_if = "Option::is_none")]
1262    pub stop_reason: Option<String>,
1263    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1264    pub rest: Rest,
1265}
1266
1267#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1268#[serde(untagged)]
1269#[derive(gproxy_protocol_macros::DeclaredFields)]
1270pub enum CodeExecutionResultContent {
1271    Error(CodeExecutionError),
1272    Result(CodeExecutionResult),
1273    Encrypted(EncryptedCodeExecutionResult),
1274}
1275#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1276#[serde(rename_all = "snake_case")]
1277#[derive(gproxy_protocol_macros::DeclaredFields)]
1278pub enum CodeExecutionErrorCode {
1279    InvalidToolInput,
1280    Unavailable,
1281    TooManyRequests,
1282    ExecutionTimeExceeded,
1283}
1284#[derive(
1285    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1286)]
1287#[serde(rename_all = "snake_case")]
1288#[derive(gproxy_protocol_macros::DeclaredFields)]
1289pub struct CodeExecutionError {
1290    #[serde(rename = "type")]
1291    pub type_: CodeExecutionErrorType,
1292    pub error_code: CodeExecutionErrorCode,
1293    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1294    pub rest: Rest,
1295}
1296#[derive(
1297    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1298)]
1299#[serde(rename_all = "snake_case")]
1300#[derive(gproxy_protocol_macros::DeclaredFields)]
1301pub struct CodeExecutionOutput {
1302    #[serde(rename = "type")]
1303    pub type_: CodeExecutionOutputType,
1304    pub file_id: String,
1305    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1306    pub rest: Rest,
1307}
1308#[derive(
1309    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1310)]
1311#[serde(rename_all = "snake_case")]
1312#[derive(gproxy_protocol_macros::DeclaredFields)]
1313pub struct CodeExecutionResult {
1314    #[serde(rename = "type")]
1315    pub type_: CodeExecutionResultType,
1316    pub content: Vec<CodeExecutionOutput>,
1317    pub return_code: i64,
1318    pub stderr: String,
1319    pub stdout: String,
1320    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1321    pub rest: Rest,
1322}
1323#[derive(
1324    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1325)]
1326#[serde(rename_all = "snake_case")]
1327#[derive(gproxy_protocol_macros::DeclaredFields)]
1328pub struct EncryptedCodeExecutionResult {
1329    #[serde(rename = "type")]
1330    pub type_: EncryptedCodeExecutionResultType,
1331    pub content: Vec<CodeExecutionOutput>,
1332    pub encrypted_stdout: String,
1333    pub return_code: i64,
1334    pub stderr: String,
1335    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1336    pub rest: Rest,
1337}
1338
1339#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1340#[serde(untagged)]
1341#[derive(gproxy_protocol_macros::DeclaredFields)]
1342pub enum BashCodeExecutionResultContent {
1343    Error(BashCodeExecutionError),
1344    Result(BashCodeExecutionResult),
1345}
1346#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1347#[serde(rename_all = "snake_case")]
1348#[derive(gproxy_protocol_macros::DeclaredFields)]
1349pub enum BashCodeExecutionErrorCode {
1350    InvalidToolInput,
1351    Unavailable,
1352    TooManyRequests,
1353    ExecutionTimeExceeded,
1354    OutputFileTooLarge,
1355}
1356#[derive(
1357    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1358)]
1359#[serde(rename_all = "snake_case")]
1360#[derive(gproxy_protocol_macros::DeclaredFields)]
1361pub struct BashCodeExecutionError {
1362    #[serde(rename = "type")]
1363    pub type_: BashCodeExecutionErrorType,
1364    pub error_code: BashCodeExecutionErrorCode,
1365    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1366    pub rest: Rest,
1367}
1368#[derive(
1369    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1370)]
1371#[serde(rename_all = "snake_case")]
1372#[derive(gproxy_protocol_macros::DeclaredFields)]
1373pub struct BashCodeExecutionOutput {
1374    #[serde(rename = "type")]
1375    pub type_: BashCodeExecutionOutputType,
1376    pub file_id: String,
1377    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1378    pub rest: Rest,
1379}
1380#[derive(
1381    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1382)]
1383#[serde(rename_all = "snake_case")]
1384#[derive(gproxy_protocol_macros::DeclaredFields)]
1385pub struct BashCodeExecutionResult {
1386    #[serde(rename = "type")]
1387    pub type_: BashCodeExecutionResultType,
1388    pub content: Vec<BashCodeExecutionOutput>,
1389    pub return_code: i64,
1390    pub stderr: String,
1391    pub stdout: String,
1392    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1393    pub rest: Rest,
1394}
1395
1396#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1397#[serde(untagged)]
1398#[derive(gproxy_protocol_macros::DeclaredFields)]
1399pub enum TextEditorResultContent {
1400    Error(TextEditorError),
1401    View(TextEditorViewResult),
1402    Create(TextEditorCreateResult),
1403    Replace(TextEditorReplaceResult),
1404}
1405#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1406#[serde(rename_all = "snake_case")]
1407#[derive(gproxy_protocol_macros::DeclaredFields)]
1408pub enum TextEditorErrorCode {
1409    InvalidToolInput,
1410    Unavailable,
1411    TooManyRequests,
1412    ExecutionTimeExceeded,
1413    FileNotFound,
1414}
1415#[derive(
1416    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1417)]
1418#[serde(rename_all = "snake_case")]
1419#[derive(gproxy_protocol_macros::DeclaredFields)]
1420pub struct TextEditorError {
1421    #[serde(rename = "type")]
1422    pub type_: TextEditorErrorType,
1423    pub error_code: TextEditorErrorCode,
1424    #[serde(skip_serializing_if = "Option::is_none")]
1425    pub error_message: Option<String>,
1426    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1427    pub rest: Rest,
1428}
1429#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1430#[serde(rename_all = "snake_case")]
1431#[derive(gproxy_protocol_macros::DeclaredFields)]
1432pub enum TextEditorFileType {
1433    Text,
1434    Image,
1435    Pdf,
1436}
1437#[derive(
1438    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1439)]
1440#[serde(rename_all = "snake_case")]
1441#[derive(gproxy_protocol_macros::DeclaredFields)]
1442pub struct TextEditorViewResult {
1443    #[serde(rename = "type")]
1444    pub type_: TextEditorViewResultType,
1445    pub content: String,
1446    pub file_type: TextEditorFileType,
1447    #[serde(skip_serializing_if = "Option::is_none")]
1448    pub num_lines: Option<i64>,
1449    #[serde(skip_serializing_if = "Option::is_none")]
1450    pub start_line: Option<i64>,
1451    #[serde(skip_serializing_if = "Option::is_none")]
1452    pub total_lines: Option<i64>,
1453    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1454    pub rest: Rest,
1455}
1456#[derive(
1457    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1458)]
1459#[serde(rename_all = "snake_case")]
1460#[derive(gproxy_protocol_macros::DeclaredFields)]
1461pub struct TextEditorCreateResult {
1462    #[serde(rename = "type")]
1463    pub type_: TextEditorCreateResultType,
1464    pub is_file_update: bool,
1465    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1466    pub rest: Rest,
1467}
1468#[derive(
1469    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1470)]
1471#[serde(rename_all = "snake_case")]
1472#[derive(gproxy_protocol_macros::DeclaredFields)]
1473pub struct TextEditorReplaceResult {
1474    #[serde(rename = "type")]
1475    pub type_: TextEditorReplaceResultType,
1476    #[serde(skip_serializing_if = "Option::is_none")]
1477    pub lines: Option<Vec<String>>,
1478    #[serde(skip_serializing_if = "Option::is_none")]
1479    pub new_lines: Option<i64>,
1480    #[serde(skip_serializing_if = "Option::is_none")]
1481    pub new_start: Option<i64>,
1482    #[serde(skip_serializing_if = "Option::is_none")]
1483    pub old_lines: Option<i64>,
1484    #[serde(skip_serializing_if = "Option::is_none")]
1485    pub old_start: Option<i64>,
1486    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1487    pub rest: Rest,
1488}
1489
1490#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1491#[serde(untagged)]
1492#[derive(gproxy_protocol_macros::DeclaredFields)]
1493pub enum ToolSearchResultContent {
1494    Error(ToolSearchError),
1495    Search(ToolSearchResults),
1496}
1497#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1498#[serde(rename_all = "snake_case")]
1499#[derive(gproxy_protocol_macros::DeclaredFields)]
1500pub enum ToolSearchErrorCode {
1501    InvalidToolInput,
1502    Unavailable,
1503    TooManyRequests,
1504    ExecutionTimeExceeded,
1505}
1506#[derive(
1507    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1508)]
1509#[serde(rename_all = "snake_case")]
1510#[derive(gproxy_protocol_macros::DeclaredFields)]
1511pub struct ToolSearchError {
1512    #[serde(rename = "type")]
1513    pub type_: ToolSearchErrorType,
1514    pub error_code: ToolSearchErrorCode,
1515    #[serde(skip_serializing_if = "Option::is_none")]
1516    pub error_message: Option<String>,
1517    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1518    pub rest: Rest,
1519}
1520#[derive(
1521    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1522)]
1523#[serde(rename_all = "snake_case")]
1524#[derive(gproxy_protocol_macros::DeclaredFields)]
1525pub struct ToolSearchResults {
1526    #[serde(rename = "type")]
1527    pub type_: ToolSearchResultsType,
1528    pub tool_references: Vec<ToolReferenceBlock>,
1529    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1530    pub rest: Rest,
1531}
1532
1533#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1534#[serde(untagged)]
1535#[derive(gproxy_protocol_macros::DeclaredFields)]
1536pub enum MidConversationContent {
1537    Text(TextBlock),
1538    Addition(ToolAdditionBlock),
1539    Removal(ToolRemovalBlock),
1540}
1541#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1542#[serde(untagged)]
1543#[derive(gproxy_protocol_macros::DeclaredFields)]
1544pub enum ToolAdditionReference {
1545    Tool(ToolReference),
1546    Mcp(McpToolReference),
1547    Toolset(McpToolsetReference),
1548    Definition(ToolDefinition),
1549}
1550#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1551#[serde(untagged)]
1552#[derive(gproxy_protocol_macros::DeclaredFields)]
1553pub enum ToolChangeReference {
1554    Tool(ToolReference),
1555    Mcp(McpToolReference),
1556    Toolset(McpToolsetReference),
1557}
1558#[derive(
1559    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1560)]
1561#[serde(rename_all = "snake_case")]
1562#[derive(gproxy_protocol_macros::DeclaredFields)]
1563pub struct ToolReference {
1564    pub name: String,
1565    #[serde(rename = "type")]
1566    pub type_: ToolReferenceType,
1567    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1568    pub rest: Rest,
1569}
1570#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1571#[serde(rename_all = "snake_case")]
1572#[derive(gproxy_protocol_macros::DeclaredFields)]
1573pub enum ToolReferenceType {
1574    ToolReference,
1575}
1576#[derive(
1577    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1578)]
1579#[serde(rename_all = "snake_case")]
1580#[derive(gproxy_protocol_macros::DeclaredFields)]
1581pub struct McpToolReference {
1582    pub name: String,
1583    pub server_name: String,
1584    #[serde(rename = "type")]
1585    pub type_: McpToolReferenceType,
1586    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1587    pub rest: Rest,
1588}
1589#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1590#[serde(rename_all = "snake_case")]
1591#[derive(gproxy_protocol_macros::DeclaredFields)]
1592pub enum McpToolReferenceType {
1593    McpToolReference,
1594}
1595#[derive(
1596    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1597)]
1598#[serde(rename_all = "snake_case")]
1599#[derive(gproxy_protocol_macros::DeclaredFields)]
1600pub struct McpToolsetReference {
1601    pub server_name: String,
1602    #[serde(rename = "type")]
1603    pub type_: McpToolsetReferenceType,
1604    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1605    pub rest: Rest,
1606}
1607#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1608#[serde(rename_all = "snake_case")]
1609#[derive(gproxy_protocol_macros::DeclaredFields)]
1610pub enum McpToolsetReferenceType {
1611    McpToolsetReference,
1612}
1613#[derive(
1614    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1615)]
1616#[serde(rename_all = "snake_case")]
1617#[derive(gproxy_protocol_macros::DeclaredFields)]
1618pub struct FallbackInfo {
1619    pub model: String,
1620    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1621    pub rest: Rest,
1622}
1623
1624#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1625#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1626#[derive(gproxy_protocol_macros::DeclaredFields)]
1627pub enum TextBlockType {
1628    #[serde(rename = "text")]
1629    Tag,
1630}
1631
1632#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1633#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1634#[derive(gproxy_protocol_macros::DeclaredFields)]
1635pub enum ImageBlockType {
1636    #[serde(rename = "image")]
1637    Tag,
1638}
1639
1640#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1641#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1642#[derive(gproxy_protocol_macros::DeclaredFields)]
1643pub enum DocumentBlockType {
1644    #[serde(rename = "document")]
1645    Tag,
1646}
1647
1648#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1649#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1650#[derive(gproxy_protocol_macros::DeclaredFields)]
1651pub enum ThinkingBlockType {
1652    #[serde(rename = "thinking")]
1653    Tag,
1654}
1655
1656#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1657#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1658#[derive(gproxy_protocol_macros::DeclaredFields)]
1659pub enum RedactedThinkingBlockType {
1660    #[serde(rename = "redacted_thinking")]
1661    Tag,
1662}
1663
1664#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1665#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1666#[derive(gproxy_protocol_macros::DeclaredFields)]
1667pub enum ToolUseBlockType {
1668    #[serde(rename = "tool_use")]
1669    Tag,
1670}
1671
1672#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1673#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1674#[derive(gproxy_protocol_macros::DeclaredFields)]
1675pub enum ToolResultBlockType {
1676    #[serde(rename = "tool_result")]
1677    Tag,
1678}
1679
1680#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1681#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1682#[derive(gproxy_protocol_macros::DeclaredFields)]
1683pub enum ServerToolUseBlockType {
1684    #[serde(rename = "server_tool_use")]
1685    Tag,
1686}
1687
1688#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1689#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1690#[derive(gproxy_protocol_macros::DeclaredFields)]
1691pub enum SearchResultBlockType {
1692    #[serde(rename = "search_result")]
1693    Tag,
1694}
1695
1696#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1697#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1698#[derive(gproxy_protocol_macros::DeclaredFields)]
1699pub enum ToolReferenceBlockType {
1700    #[serde(rename = "tool_reference")]
1701    Tag,
1702}
1703
1704#[derive(
1705    Debug,
1706    Clone,
1707    Copy,
1708    PartialEq,
1709    Eq,
1710    Serialize,
1711    Deserialize,
1712    gproxy_protocol_macros::DeclaredFields,
1713)]
1714#[serde(rename_all = "snake_case")]
1715#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1716pub enum SystemMessageClearAt {
1717    NextUserMessage,
1718    Never,
1719}
1720
1721#[derive(
1722    Debug,
1723    Clone,
1724    PartialEq,
1725    Eq,
1726    Serialize,
1727    Deserialize,
1728    gproxy_protocol_macros::WireBuilder,
1729    gproxy_protocol_macros::DeclaredFields,
1730)]
1731#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1732pub struct SystemMessageOutputConfig {
1733    #[serde(skip_serializing_if = "Option::is_none")]
1734    pub effort: Option<super::count_tokens::Effort>,
1735    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1736    pub rest: Rest,
1737}
1738
1739#[derive(
1740    Debug,
1741    Clone,
1742    Copy,
1743    PartialEq,
1744    Eq,
1745    Serialize,
1746    Deserialize,
1747    gproxy_protocol_macros::DeclaredFields,
1748)]
1749#[serde(rename_all = "snake_case")]
1750#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1751pub enum ToolDefinitionType {
1752    ToolDefinition,
1753}
1754
1755#[derive(
1756    Debug,
1757    Clone,
1758    PartialEq,
1759    Eq,
1760    Serialize,
1761    Deserialize,
1762    gproxy_protocol_macros::WireBuilder,
1763    gproxy_protocol_macros::DeclaredFields,
1764)]
1765#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1766pub struct ToolDefinition {
1767    #[serde(rename = "type")]
1768    pub type_: ToolDefinitionType,
1769    pub definition: Box<super::tools::ToolUnion>,
1770    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1771    pub rest: Rest,
1772}
1773
1774#[derive(
1775    Debug,
1776    Clone,
1777    Copy,
1778    PartialEq,
1779    Eq,
1780    Serialize,
1781    Deserialize,
1782    gproxy_protocol_macros::DeclaredFields,
1783)]
1784#[serde(rename_all = "snake_case")]
1785#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1786pub enum McpToolListingType {
1787    McpToolListing,
1788}
1789
1790#[derive(
1791    Debug,
1792    Clone,
1793    PartialEq,
1794    Eq,
1795    Serialize,
1796    Deserialize,
1797    gproxy_protocol_macros::WireBuilder,
1798    gproxy_protocol_macros::DeclaredFields,
1799)]
1800#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1801pub struct McpToolListingBlock {
1802    #[serde(rename = "type")]
1803    pub type_: McpToolListingType,
1804    pub mcp_server_name: String,
1805    pub tools: Vec<super::tools::McpListedTool>,
1806    #[serde(skip_serializing_if = "Option::is_none")]
1807    pub cache_control: Option<CacheControl>,
1808    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1809    pub rest: Rest,
1810}
1811
1812#[derive(
1813    Debug,
1814    Clone,
1815    Copy,
1816    PartialEq,
1817    Eq,
1818    Serialize,
1819    Deserialize,
1820    gproxy_protocol_macros::DeclaredFields,
1821)]
1822#[serde(rename_all = "snake_case")]
1823#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1824pub enum BrowserStateType {
1825    BrowserState,
1826}
1827
1828#[derive(
1829    Debug,
1830    Clone,
1831    PartialEq,
1832    Eq,
1833    Serialize,
1834    Deserialize,
1835    gproxy_protocol_macros::WireBuilder,
1836    gproxy_protocol_macros::DeclaredFields,
1837)]
1838#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1839pub struct BrowserStateBlock {
1840    #[serde(rename = "type")]
1841    pub type_: BrowserStateType,
1842    pub tabs: Vec<BrowserStateTab>,
1843    #[serde(skip_serializing_if = "Option::is_none")]
1844    pub cache_control: Option<CacheControl>,
1845    #[serde(skip_serializing_if = "Option::is_none")]
1846    pub state_changes: Option<Vec<BrowserStateChange>>,
1847    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1848    pub rest: Rest,
1849}
1850
1851#[derive(
1852    Debug,
1853    Clone,
1854    PartialEq,
1855    Eq,
1856    Serialize,
1857    Deserialize,
1858    gproxy_protocol_macros::WireBuilder,
1859    gproxy_protocol_macros::DeclaredFields,
1860)]
1861#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1862pub struct BrowserStateTab {
1863    pub tab_id: String,
1864    pub title: String,
1865    pub url: String,
1866    #[serde(skip_serializing_if = "Option::is_none")]
1867    pub active: Option<bool>,
1868    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1869    pub rest: Rest,
1870}
1871
1872#[derive(
1873    Debug,
1874    Clone,
1875    PartialEq,
1876    Eq,
1877    Serialize,
1878    Deserialize,
1879    gproxy_protocol_macros::WireBuilder,
1880    gproxy_protocol_macros::DeclaredFields,
1881)]
1882#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1883pub struct BrowserTabOpened {
1884    pub tab_id: String,
1885    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1886    pub rest: Rest,
1887}
1888
1889#[derive(
1890    Debug,
1891    Clone,
1892    PartialEq,
1893    Eq,
1894    Serialize,
1895    Deserialize,
1896    gproxy_protocol_macros::WireBuilder,
1897    gproxy_protocol_macros::DeclaredFields,
1898)]
1899#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1900pub struct BrowserDownloadStarted {
1901    pub download_id: String,
1902    pub url: String,
1903    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1904    pub rest: Rest,
1905}
1906
1907#[derive(
1908    Debug,
1909    Clone,
1910    PartialEq,
1911    Eq,
1912    Serialize,
1913    Deserialize,
1914    gproxy_protocol_macros::WireBuilder,
1915    gproxy_protocol_macros::DeclaredFields,
1916)]
1917#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1918pub struct BrowserDownloadCompleted {
1919    pub download_id: String,
1920    pub url: String,
1921    #[serde(skip_serializing_if = "Option::is_none")]
1922    pub path: Option<String>,
1923    #[serde(skip_serializing_if = "Option::is_none")]
1924    pub size_bytes: Option<u64>,
1925    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1926    pub rest: Rest,
1927}
1928
1929#[derive(
1930    Debug,
1931    Clone,
1932    PartialEq,
1933    Eq,
1934    Serialize,
1935    Deserialize,
1936    gproxy_protocol_macros::WireBuilder,
1937    gproxy_protocol_macros::DeclaredFields,
1938)]
1939#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1940pub struct BrowserDownloadFailed {
1941    pub download_id: String,
1942    pub url: String,
1943    #[serde(skip_serializing_if = "Option::is_none")]
1944    pub error: Option<String>,
1945    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1946    pub rest: Rest,
1947}
1948
1949#[derive(
1950    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::DeclaredFields,
1951)]
1952#[serde(tag = "type", rename_all = "snake_case")]
1953#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1954pub enum BrowserStateChange {
1955    TabOpened(BrowserTabOpened),
1956    DownloadStarted(BrowserDownloadStarted),
1957    DownloadCompleted(BrowserDownloadCompleted),
1958    DownloadFailed(BrowserDownloadFailed),
1959}
gproxy_protocol/wire/claude/content.rs

gproxy_protocol/wire/claude/
content.rs
