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