Skip to main content

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