gproxy_protocol/wire/claude/
tools.rs

1use serde::{Deserialize, Serialize};
2use serde_json::Value;
3
4use super::content::{CacheControl, CitationsConfig};
5use crate::Rest;
6
7#[derive(
8    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
9)]
10#[serde(rename_all = "snake_case")]
11#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
12#[derive(gproxy_protocol_macros::DeclaredFields)]
13pub struct Tool {
14    pub input_schema: JsonSchema,
15    pub name: String,
16    #[serde(skip_serializing_if = "Option::is_none")]
17    pub allowed_callers: Option<Vec<AllowedCaller>>,
18    #[serde(skip_serializing_if = "Option::is_none")]
19    pub cache_control: Option<CacheControl>,
20    #[serde(skip_serializing_if = "Option::is_none")]
21    pub defer_loading: Option<bool>,
22    #[serde(skip_serializing_if = "Option::is_none")]
23    pub description: Option<String>,
24    #[serde(skip_serializing_if = "Option::is_none")]
25    pub eager_input_streaming: Option<bool>,
26    #[serde(skip_serializing_if = "Option::is_none")]
27    pub input_examples: Option<Vec<Value>>,
28    #[serde(skip_serializing_if = "Option::is_none")]
29    pub strict: Option<bool>,
30    #[serde(skip_serializing_if = "Option::is_none")]
31    #[serde(rename = "type")]
32    pub type_: Option<ToolType>,
33    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
34    pub rest: Rest,
35}
36
37#[derive(
38    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
39)]
40#[serde(rename_all = "snake_case")]
41#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
42#[derive(gproxy_protocol_macros::DeclaredFields)]
43pub struct JsonSchema {
44    #[serde(rename = "type")]
45    pub type_: JsonSchemaType,
46    #[serde(skip_serializing_if = "Option::is_none")]
47    pub properties: Option<Value>,
48    #[serde(skip_serializing_if = "Option::is_none")]
49    pub required: Option<Vec<String>>,
50    #[serde(
51        rename = "additionalProperties",
52        skip_serializing_if = "Option::is_none"
53    )]
54    pub additional_properties: Option<Value>,
55    #[serde(rename = "$defs", skip_serializing_if = "Option::is_none")]
56    pub defs: Option<Value>,
57    #[serde(rename = "definitions", skip_serializing_if = "Option::is_none")]
58    pub definitions: Option<Value>,
59    #[serde(rename = "$schema", skip_serializing_if = "Option::is_none")]
60    pub schema_uri: Option<String>,
61    #[serde(rename = "$id", skip_serializing_if = "Option::is_none")]
62    pub id: Option<String>,
63    #[serde(rename = "$ref", skip_serializing_if = "Option::is_none")]
64    pub reference: Option<String>,
65    #[serde(rename = "$anchor", skip_serializing_if = "Option::is_none")]
66    pub anchor: Option<String>,
67    #[serde(rename = "$dynamicRef", skip_serializing_if = "Option::is_none")]
68    pub dynamic_reference: Option<String>,
69    #[serde(rename = "$dynamicAnchor", skip_serializing_if = "Option::is_none")]
70    pub dynamic_anchor: Option<String>,
71    #[serde(rename = "$comment", skip_serializing_if = "Option::is_none")]
72    pub comment: Option<String>,
73    #[serde(rename = "title", skip_serializing_if = "Option::is_none")]
74    pub title: Option<String>,
75    #[serde(rename = "description", skip_serializing_if = "Option::is_none")]
76    pub description: Option<String>,
77    #[serde(rename = "default", skip_serializing_if = "Option::is_none")]
78    pub default_value: Option<Value>,
79    #[serde(rename = "examples", skip_serializing_if = "Option::is_none")]
80    pub examples: Option<Vec<Value>>,
81    #[serde(rename = "enum", skip_serializing_if = "Option::is_none")]
82    pub enum_values: Option<Vec<Value>>,
83    #[serde(rename = "const", skip_serializing_if = "Option::is_none")]
84    pub const_value: Option<Value>,
85    #[serde(rename = "allOf", skip_serializing_if = "Option::is_none")]
86    pub all_of: Option<Vec<Value>>,
87    #[serde(rename = "anyOf", skip_serializing_if = "Option::is_none")]
88    pub any_of: Option<Vec<Value>>,
89    #[serde(rename = "oneOf", skip_serializing_if = "Option::is_none")]
90    pub one_of: Option<Vec<Value>>,
91    #[serde(rename = "not", skip_serializing_if = "Option::is_none")]
92    pub not: Option<Value>,
93    #[serde(rename = "if", skip_serializing_if = "Option::is_none")]
94    pub if_schema: Option<Value>,
95    #[serde(rename = "then", skip_serializing_if = "Option::is_none")]
96    pub then_schema: Option<Value>,
97    #[serde(rename = "else", skip_serializing_if = "Option::is_none")]
98    pub else_schema: Option<Value>,
99    #[serde(rename = "patternProperties", skip_serializing_if = "Option::is_none")]
100    pub pattern_properties: Option<Value>,
101    #[serde(rename = "propertyNames", skip_serializing_if = "Option::is_none")]
102    pub property_names: Option<Value>,
103    #[serde(rename = "dependentRequired", skip_serializing_if = "Option::is_none")]
104    pub dependent_required: Option<Value>,
105    #[serde(rename = "dependentSchemas", skip_serializing_if = "Option::is_none")]
106    pub dependent_schemas: Option<Value>,
107    #[serde(rename = "dependencies", skip_serializing_if = "Option::is_none")]
108    pub dependencies: Option<Value>,
109    #[serde(
110        rename = "unevaluatedProperties",
111        skip_serializing_if = "Option::is_none"
112    )]
113    pub unevaluated_properties: Option<Value>,
114    #[serde(rename = "minProperties", skip_serializing_if = "Option::is_none")]
115    pub min_properties: Option<u64>,
116    #[serde(rename = "maxProperties", skip_serializing_if = "Option::is_none")]
117    pub max_properties: Option<u64>,
118    #[serde(rename = "readOnly", skip_serializing_if = "Option::is_none")]
119    pub read_only: Option<bool>,
120    #[serde(rename = "writeOnly", skip_serializing_if = "Option::is_none")]
121    pub write_only: Option<bool>,
122    #[serde(rename = "deprecated", skip_serializing_if = "Option::is_none")]
123    pub deprecated: Option<bool>,
124    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
125    pub rest: Rest,
126}
127
128#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
129#[serde(rename_all = "snake_case")]
130#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
131#[derive(gproxy_protocol_macros::DeclaredFields)]
132pub enum JsonSchemaType {
133    Object,
134}
135#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
136#[serde(rename_all = "snake_case")]
137#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
138#[derive(gproxy_protocol_macros::DeclaredFields)]
139pub enum ToolType {
140    Custom,
141}
142#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
143#[serde(rename_all = "snake_case")]
144#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
145#[derive(gproxy_protocol_macros::DeclaredFields)]
146pub enum AllowedCaller {
147    Direct,
148    #[serde(rename = "code_execution_20250825")]
149    CodeExecution20250825,
150    #[serde(rename = "code_execution_20260120")]
151    CodeExecution20260120,
152    #[serde(rename = "code_execution_20260521")]
153    CodeExecution20260521,
154}
155
156#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
157#[serde(untagged)]
158#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
159#[derive(gproxy_protocol_macros::DeclaredFields)]
160#[allow(clippy::large_enum_variant)]
161pub enum ToolUnion {
162    BrowserToolset20260801(BrowserToolset20260801),
163    ComputerToolset20260801(ComputerToolset20260801),
164    Custom(Tool),
165    Mcp(McpToolset),
166    Bash20241022(BashTool20241022),
167    Bash20250124(BashTool20250124),
168    CodeExecution20250522(CodeExecutionTool20250522),
169    CodeExecution20250825(CodeExecutionTool20250825),
170    CodeExecution20260120(CodeExecutionTool20260120),
171    CodeExecution20260521(CodeExecutionTool20260521),
172    Computer20241022(ComputerTool20241022),
173    Memory20250818(MemoryTool20250818),
174    Computer20250124(ComputerTool20250124),
175    TextEditor20241022(TextEditorTool20241022),
176    Computer20251124(ComputerTool20251124),
177    TextEditor20250124(TextEditorTool20250124),
178    TextEditor20250429(TextEditorTool20250429),
179    TextEditor20250728(TextEditorTool20250728),
180    WebSearch20250305(WebSearchTool20250305),
181    WebFetch20250910(WebFetchTool20250910),
182    WebSearch20260209(WebSearchTool20260209),
183    WebFetch20260209(WebFetchTool20260209),
184    WebFetch20260309(WebFetchTool20260309),
185    WebSearch20260318(WebSearchTool20260318),
186    WebFetch20260318(WebFetchTool20260318),
187    Advisor20260301(AdvisorTool20260301),
188    ToolSearchBm2520251119(ToolSearchBm25Tool20251119),
189    ToolSearchRegex20251119(ToolSearchRegexTool20251119),
190}
191
192#[derive(
193    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
194)]
195#[serde(rename_all = "snake_case")]
196#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
197#[derive(gproxy_protocol_macros::DeclaredFields)]
198pub struct McpToolset {
199    #[serde(skip_serializing_if = "Option::is_none")]
200    pub tools: Option<Vec<McpListedTool>>,
201
202    pub mcp_server_name: String,
203    #[serde(rename = "type")]
204    pub type_: McpToolsetType,
205    #[serde(skip_serializing_if = "Option::is_none")]
206    pub cache_control: Option<CacheControl>,
207    #[serde(skip_serializing_if = "Option::is_none")]
208    pub configs: Option<std::collections::BTreeMap<String, McpToolConfig>>,
209    #[serde(skip_serializing_if = "Option::is_none")]
210    pub default_config: Option<McpToolDefaultConfig>,
211    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
212    pub rest: Rest,
213}
214
215#[derive(
216    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
217)]
218#[serde(rename_all = "snake_case")]
219#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
220#[derive(gproxy_protocol_macros::DeclaredFields)]
221pub struct McpToolConfig {
222    #[serde(skip_serializing_if = "Option::is_none")]
223    pub defer_loading: Option<bool>,
224    #[serde(skip_serializing_if = "Option::is_none")]
225    pub enabled: Option<bool>,
226    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
227    pub rest: Rest,
228}
229
230#[derive(
231    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
232)]
233#[serde(rename_all = "snake_case")]
234#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
235#[derive(gproxy_protocol_macros::DeclaredFields)]
236pub struct McpToolDefaultConfig {
237    #[serde(skip_serializing_if = "Option::is_none")]
238    pub defer_loading: Option<bool>,
239    #[serde(skip_serializing_if = "Option::is_none")]
240    pub enabled: Option<bool>,
241    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
242    pub rest: Rest,
243}
244#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
245#[serde(rename_all = "snake_case")]
246#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
247#[derive(gproxy_protocol_macros::DeclaredFields)]
248pub enum McpToolsetType {
249    McpToolset,
250}
251
252type Examples = Vec<Value>;
253
254#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
255#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
256#[derive(gproxy_protocol_macros::DeclaredFields)]
257pub enum BashTool20241022Name {
258    #[serde(rename = "bash")]
259    Name,
260}
261
262#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
263#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
264#[derive(gproxy_protocol_macros::DeclaredFields)]
265pub enum BashTool20241022Type {
266    #[serde(rename = "bash_20241022")]
267    Tag,
268}
269#[derive(
270    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
271)]
272#[serde(rename_all = "snake_case")]
273#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
274#[derive(gproxy_protocol_macros::DeclaredFields)]
275pub struct BashTool20241022 {
276    pub name: BashTool20241022Name,
277    #[serde(rename = "type")]
278    pub type_: BashTool20241022Type,
279    #[serde(skip_serializing_if = "Option::is_none")]
280    pub allowed_callers: Option<Vec<AllowedCaller>>,
281    #[serde(skip_serializing_if = "Option::is_none")]
282    pub cache_control: Option<CacheControl>,
283    #[serde(skip_serializing_if = "Option::is_none")]
284    pub defer_loading: Option<bool>,
285    #[serde(skip_serializing_if = "Option::is_none")]
286    pub input_examples: Option<Examples>,
287    #[serde(skip_serializing_if = "Option::is_none")]
288    pub strict: Option<bool>,
289    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
290    pub rest: Rest,
291}
292
293#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
294#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
295#[derive(gproxy_protocol_macros::DeclaredFields)]
296pub enum BashTool20250124Name {
297    #[serde(rename = "bash")]
298    Name,
299}
300
301#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
302#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
303#[derive(gproxy_protocol_macros::DeclaredFields)]
304pub enum BashTool20250124Type {
305    #[serde(rename = "bash_20250124")]
306    Tag,
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)]
314pub struct BashTool20250124 {
315    pub name: BashTool20250124Name,
316    #[serde(rename = "type")]
317    pub type_: BashTool20250124Type,
318    #[serde(skip_serializing_if = "Option::is_none")]
319    pub allowed_callers: Option<Vec<AllowedCaller>>,
320    #[serde(skip_serializing_if = "Option::is_none")]
321    pub cache_control: Option<CacheControl>,
322    #[serde(skip_serializing_if = "Option::is_none")]
323    pub defer_loading: Option<bool>,
324    #[serde(skip_serializing_if = "Option::is_none")]
325    pub input_examples: Option<Examples>,
326    #[serde(skip_serializing_if = "Option::is_none")]
327    pub strict: Option<bool>,
328    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
329    pub rest: Rest,
330}
331
332#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
333#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
334#[derive(gproxy_protocol_macros::DeclaredFields)]
335pub enum CodeExecutionTool20250522Name {
336    #[serde(rename = "code_execution")]
337    Name,
338}
339
340#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
341#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
342#[derive(gproxy_protocol_macros::DeclaredFields)]
343pub enum CodeExecutionTool20250522Type {
344    #[serde(rename = "code_execution_20250522")]
345    Tag,
346}
347#[derive(
348    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
349)]
350#[serde(rename_all = "snake_case")]
351#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
352#[derive(gproxy_protocol_macros::DeclaredFields)]
353pub struct CodeExecutionTool20250522 {
354    pub name: CodeExecutionTool20250522Name,
355    #[serde(rename = "type")]
356    pub type_: CodeExecutionTool20250522Type,
357    #[serde(skip_serializing_if = "Option::is_none")]
358    pub allowed_callers: Option<Vec<AllowedCaller>>,
359    #[serde(skip_serializing_if = "Option::is_none")]
360    pub cache_control: Option<CacheControl>,
361    #[serde(skip_serializing_if = "Option::is_none")]
362    pub defer_loading: Option<bool>,
363    #[serde(skip_serializing_if = "Option::is_none")]
364    pub strict: Option<bool>,
365    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
366    pub rest: Rest,
367}
368
369#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
370#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
371#[derive(gproxy_protocol_macros::DeclaredFields)]
372pub enum CodeExecutionTool20250825Name {
373    #[serde(rename = "code_execution")]
374    Name,
375}
376
377#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
378#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
379#[derive(gproxy_protocol_macros::DeclaredFields)]
380pub enum CodeExecutionTool20250825Type {
381    #[serde(rename = "code_execution_20250825")]
382    Tag,
383}
384#[derive(
385    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
386)]
387#[serde(rename_all = "snake_case")]
388#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
389#[derive(gproxy_protocol_macros::DeclaredFields)]
390pub struct CodeExecutionTool20250825 {
391    pub name: CodeExecutionTool20250825Name,
392    #[serde(rename = "type")]
393    pub type_: CodeExecutionTool20250825Type,
394    #[serde(skip_serializing_if = "Option::is_none")]
395    pub allowed_callers: Option<Vec<AllowedCaller>>,
396    #[serde(skip_serializing_if = "Option::is_none")]
397    pub cache_control: Option<CacheControl>,
398    #[serde(skip_serializing_if = "Option::is_none")]
399    pub defer_loading: Option<bool>,
400    #[serde(skip_serializing_if = "Option::is_none")]
401    pub strict: Option<bool>,
402    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
403    pub rest: Rest,
404}
405
406#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
407#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
408#[derive(gproxy_protocol_macros::DeclaredFields)]
409pub enum CodeExecutionTool20260120Name {
410    #[serde(rename = "code_execution")]
411    Name,
412}
413
414#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
415#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
416#[derive(gproxy_protocol_macros::DeclaredFields)]
417pub enum CodeExecutionTool20260120Type {
418    #[serde(rename = "code_execution_20260120")]
419    Tag,
420}
421#[derive(
422    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
423)]
424#[serde(rename_all = "snake_case")]
425#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
426#[derive(gproxy_protocol_macros::DeclaredFields)]
427pub struct CodeExecutionTool20260120 {
428    pub name: CodeExecutionTool20260120Name,
429    #[serde(rename = "type")]
430    pub type_: CodeExecutionTool20260120Type,
431    #[serde(skip_serializing_if = "Option::is_none")]
432    pub allowed_callers: Option<Vec<AllowedCaller>>,
433    #[serde(skip_serializing_if = "Option::is_none")]
434    pub cache_control: Option<CacheControl>,
435    #[serde(skip_serializing_if = "Option::is_none")]
436    pub defer_loading: Option<bool>,
437    #[serde(skip_serializing_if = "Option::is_none")]
438    pub strict: Option<bool>,
439    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
440    pub rest: Rest,
441}
442
443#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
444#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
445#[derive(gproxy_protocol_macros::DeclaredFields)]
446pub enum CodeExecutionTool20260521Name {
447    #[serde(rename = "code_execution")]
448    Name,
449}
450
451#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
452#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
453#[derive(gproxy_protocol_macros::DeclaredFields)]
454pub enum CodeExecutionTool20260521Type {
455    #[serde(rename = "code_execution_20260521")]
456    Tag,
457}
458#[derive(
459    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
460)]
461#[serde(rename_all = "snake_case")]
462#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
463#[derive(gproxy_protocol_macros::DeclaredFields)]
464pub struct CodeExecutionTool20260521 {
465    pub name: CodeExecutionTool20260521Name,
466    #[serde(rename = "type")]
467    pub type_: CodeExecutionTool20260521Type,
468    #[serde(skip_serializing_if = "Option::is_none")]
469    pub allowed_callers: Option<Vec<AllowedCaller>>,
470    #[serde(skip_serializing_if = "Option::is_none")]
471    pub cache_control: Option<CacheControl>,
472    #[serde(skip_serializing_if = "Option::is_none")]
473    pub defer_loading: Option<bool>,
474    #[serde(skip_serializing_if = "Option::is_none")]
475    pub strict: Option<bool>,
476    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
477    pub rest: Rest,
478}
479
480#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
481#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
482#[derive(gproxy_protocol_macros::DeclaredFields)]
483pub enum MemoryTool20250818Name {
484    #[serde(rename = "memory")]
485    Name,
486}
487
488#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
489#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
490#[derive(gproxy_protocol_macros::DeclaredFields)]
491pub enum MemoryTool20250818Type {
492    #[serde(rename = "memory_20250818")]
493    Tag,
494}
495#[derive(
496    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
497)]
498#[serde(rename_all = "snake_case")]
499#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
500#[derive(gproxy_protocol_macros::DeclaredFields)]
501pub struct MemoryTool20250818 {
502    pub name: MemoryTool20250818Name,
503    #[serde(rename = "type")]
504    pub type_: MemoryTool20250818Type,
505    #[serde(skip_serializing_if = "Option::is_none")]
506    pub allowed_callers: Option<Vec<AllowedCaller>>,
507    #[serde(skip_serializing_if = "Option::is_none")]
508    pub cache_control: Option<CacheControl>,
509    #[serde(skip_serializing_if = "Option::is_none")]
510    pub defer_loading: Option<bool>,
511    #[serde(skip_serializing_if = "Option::is_none")]
512    pub input_examples: Option<Examples>,
513    #[serde(skip_serializing_if = "Option::is_none")]
514    pub strict: Option<bool>,
515    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
516    pub rest: Rest,
517}
518
519#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
520#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
521#[derive(gproxy_protocol_macros::DeclaredFields)]
522pub enum ComputerTool20241022Name {
523    #[serde(rename = "computer")]
524    Name,
525}
526
527#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
528#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
529#[derive(gproxy_protocol_macros::DeclaredFields)]
530pub enum ComputerTool20241022Type {
531    #[serde(rename = "computer_20241022")]
532    Tag,
533}
534#[derive(
535    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
536)]
537#[serde(rename_all = "snake_case")]
538#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
539#[derive(gproxy_protocol_macros::DeclaredFields)]
540pub struct ComputerTool20241022 {
541    pub name: ComputerTool20241022Name,
542    #[serde(rename = "type")]
543    pub type_: ComputerTool20241022Type,
544    pub display_height_px: i64,
545    pub display_width_px: i64,
546    #[serde(skip_serializing_if = "Option::is_none")]
547    pub allowed_callers: Option<Vec<AllowedCaller>>,
548    #[serde(skip_serializing_if = "Option::is_none")]
549    pub cache_control: Option<CacheControl>,
550    #[serde(skip_serializing_if = "Option::is_none")]
551    pub defer_loading: Option<bool>,
552    #[serde(skip_serializing_if = "Option::is_none")]
553    pub display_number: Option<i64>,
554    #[serde(skip_serializing_if = "Option::is_none")]
555    pub input_examples: Option<Examples>,
556    #[serde(skip_serializing_if = "Option::is_none")]
557    pub strict: Option<bool>,
558    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
559    pub rest: Rest,
560}
561
562#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
563#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
564#[derive(gproxy_protocol_macros::DeclaredFields)]
565pub enum ComputerTool20250124Name {
566    #[serde(rename = "computer")]
567    Name,
568}
569
570#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
571#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
572#[derive(gproxy_protocol_macros::DeclaredFields)]
573pub enum ComputerTool20250124Type {
574    #[serde(rename = "computer_20250124")]
575    Tag,
576}
577#[derive(
578    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
579)]
580#[serde(rename_all = "snake_case")]
581#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
582#[derive(gproxy_protocol_macros::DeclaredFields)]
583pub struct ComputerTool20250124 {
584    pub name: ComputerTool20250124Name,
585    #[serde(rename = "type")]
586    pub type_: ComputerTool20250124Type,
587    pub display_height_px: i64,
588    pub display_width_px: i64,
589    #[serde(skip_serializing_if = "Option::is_none")]
590    pub allowed_callers: Option<Vec<AllowedCaller>>,
591    #[serde(skip_serializing_if = "Option::is_none")]
592    pub cache_control: Option<CacheControl>,
593    #[serde(skip_serializing_if = "Option::is_none")]
594    pub defer_loading: Option<bool>,
595    #[serde(skip_serializing_if = "Option::is_none")]
596    pub display_number: Option<i64>,
597    #[serde(skip_serializing_if = "Option::is_none")]
598    pub input_examples: Option<Examples>,
599    #[serde(skip_serializing_if = "Option::is_none")]
600    pub strict: Option<bool>,
601    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
602    pub rest: Rest,
603}
604
605#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
606#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
607#[derive(gproxy_protocol_macros::DeclaredFields)]
608pub enum ComputerTool20251124Name {
609    #[serde(rename = "computer")]
610    Name,
611}
612
613#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
614#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
615#[derive(gproxy_protocol_macros::DeclaredFields)]
616pub enum ComputerTool20251124Type {
617    #[serde(rename = "computer_20251124")]
618    Tag,
619}
620#[derive(
621    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
622)]
623#[serde(rename_all = "snake_case")]
624#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
625#[derive(gproxy_protocol_macros::DeclaredFields)]
626pub struct ComputerTool20251124 {
627    pub name: ComputerTool20251124Name,
628    #[serde(rename = "type")]
629    pub type_: ComputerTool20251124Type,
630    pub display_height_px: i64,
631    pub display_width_px: i64,
632    #[serde(skip_serializing_if = "Option::is_none")]
633    pub allowed_callers: Option<Vec<AllowedCaller>>,
634    #[serde(skip_serializing_if = "Option::is_none")]
635    pub cache_control: Option<CacheControl>,
636    #[serde(skip_serializing_if = "Option::is_none")]
637    pub defer_loading: Option<bool>,
638    #[serde(skip_serializing_if = "Option::is_none")]
639    pub display_number: Option<i64>,
640    #[serde(skip_serializing_if = "Option::is_none")]
641    pub enable_zoom: Option<bool>,
642    #[serde(skip_serializing_if = "Option::is_none")]
643    pub input_examples: Option<Examples>,
644    #[serde(skip_serializing_if = "Option::is_none")]
645    pub strict: Option<bool>,
646    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
647    pub rest: Rest,
648}
649
650#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
651#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
652#[derive(gproxy_protocol_macros::DeclaredFields)]
653pub enum TextEditorTool20241022Name {
654    #[serde(rename = "str_replace_editor")]
655    Name,
656}
657
658#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
659#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
660#[derive(gproxy_protocol_macros::DeclaredFields)]
661pub enum TextEditorTool20241022Type {
662    #[serde(rename = "text_editor_20241022")]
663    Tag,
664}
665#[derive(
666    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
667)]
668#[serde(rename_all = "snake_case")]
669#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
670#[derive(gproxy_protocol_macros::DeclaredFields)]
671pub struct TextEditorTool20241022 {
672    pub name: TextEditorTool20241022Name,
673    #[serde(rename = "type")]
674    pub type_: TextEditorTool20241022Type,
675    #[serde(skip_serializing_if = "Option::is_none")]
676    pub allowed_callers: Option<Vec<AllowedCaller>>,
677    #[serde(skip_serializing_if = "Option::is_none")]
678    pub cache_control: Option<CacheControl>,
679    #[serde(skip_serializing_if = "Option::is_none")]
680    pub defer_loading: Option<bool>,
681    #[serde(skip_serializing_if = "Option::is_none")]
682    pub input_examples: Option<Examples>,
683    #[serde(skip_serializing_if = "Option::is_none")]
684    pub strict: Option<bool>,
685    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
686    pub rest: Rest,
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)]
692pub enum TextEditorTool20250124Name {
693    #[serde(rename = "str_replace_editor")]
694    Name,
695}
696
697#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
698#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
699#[derive(gproxy_protocol_macros::DeclaredFields)]
700pub enum TextEditorTool20250124Type {
701    #[serde(rename = "text_editor_20250124")]
702    Tag,
703}
704#[derive(
705    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
706)]
707#[serde(rename_all = "snake_case")]
708#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
709#[derive(gproxy_protocol_macros::DeclaredFields)]
710pub struct TextEditorTool20250124 {
711    pub name: TextEditorTool20250124Name,
712    #[serde(rename = "type")]
713    pub type_: TextEditorTool20250124Type,
714    #[serde(skip_serializing_if = "Option::is_none")]
715    pub allowed_callers: Option<Vec<AllowedCaller>>,
716    #[serde(skip_serializing_if = "Option::is_none")]
717    pub cache_control: Option<CacheControl>,
718    #[serde(skip_serializing_if = "Option::is_none")]
719    pub defer_loading: Option<bool>,
720    #[serde(skip_serializing_if = "Option::is_none")]
721    pub input_examples: Option<Examples>,
722    #[serde(skip_serializing_if = "Option::is_none")]
723    pub strict: Option<bool>,
724    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
725    pub rest: Rest,
726}
727
728#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
729#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
730#[derive(gproxy_protocol_macros::DeclaredFields)]
731pub enum TextEditorTool20250429Name {
732    #[serde(rename = "str_replace_based_edit_tool")]
733    Name,
734}
735
736#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
737#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
738#[derive(gproxy_protocol_macros::DeclaredFields)]
739pub enum TextEditorTool20250429Type {
740    #[serde(rename = "text_editor_20250429")]
741    Tag,
742}
743#[derive(
744    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
745)]
746#[serde(rename_all = "snake_case")]
747#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
748#[derive(gproxy_protocol_macros::DeclaredFields)]
749pub struct TextEditorTool20250429 {
750    pub name: TextEditorTool20250429Name,
751    #[serde(rename = "type")]
752    pub type_: TextEditorTool20250429Type,
753    #[serde(skip_serializing_if = "Option::is_none")]
754    pub allowed_callers: Option<Vec<AllowedCaller>>,
755    #[serde(skip_serializing_if = "Option::is_none")]
756    pub cache_control: Option<CacheControl>,
757    #[serde(skip_serializing_if = "Option::is_none")]
758    pub defer_loading: Option<bool>,
759    #[serde(skip_serializing_if = "Option::is_none")]
760    pub input_examples: Option<Examples>,
761    #[serde(skip_serializing_if = "Option::is_none")]
762    pub strict: Option<bool>,
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)]
770pub enum TextEditorTool20250728Name {
771    #[serde(rename = "str_replace_based_edit_tool")]
772    Name,
773}
774
775#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
776#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
777#[derive(gproxy_protocol_macros::DeclaredFields)]
778pub enum TextEditorTool20250728Type {
779    #[serde(rename = "text_editor_20250728")]
780    Tag,
781}
782#[derive(
783    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
784)]
785#[serde(rename_all = "snake_case")]
786#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
787#[derive(gproxy_protocol_macros::DeclaredFields)]
788pub struct TextEditorTool20250728 {
789    pub name: TextEditorTool20250728Name,
790    #[serde(rename = "type")]
791    pub type_: TextEditorTool20250728Type,
792    #[serde(skip_serializing_if = "Option::is_none")]
793    pub allowed_callers: Option<Vec<AllowedCaller>>,
794    #[serde(skip_serializing_if = "Option::is_none")]
795    pub cache_control: Option<CacheControl>,
796    #[serde(skip_serializing_if = "Option::is_none")]
797    pub defer_loading: Option<bool>,
798    #[serde(skip_serializing_if = "Option::is_none")]
799    pub input_examples: Option<Examples>,
800    #[serde(skip_serializing_if = "Option::is_none")]
801    pub max_characters: Option<i64>,
802    #[serde(skip_serializing_if = "Option::is_none")]
803    pub strict: Option<bool>,
804    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
805    pub rest: Rest,
806}
807
808#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
809#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
810#[derive(gproxy_protocol_macros::DeclaredFields)]
811pub enum WebSearchTool20250305Name {
812    #[serde(rename = "web_search")]
813    Name,
814}
815
816#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
817#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
818#[derive(gproxy_protocol_macros::DeclaredFields)]
819pub enum WebSearchTool20250305Type {
820    #[serde(rename = "web_search_20250305")]
821    Tag,
822}
823#[derive(
824    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
825)]
826#[serde(rename_all = "snake_case")]
827#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
828#[derive(gproxy_protocol_macros::DeclaredFields)]
829pub struct WebSearchTool20250305 {
830    pub name: WebSearchTool20250305Name,
831    #[serde(rename = "type")]
832    pub type_: WebSearchTool20250305Type,
833    #[serde(skip_serializing_if = "Option::is_none")]
834    pub allowed_callers: Option<Vec<AllowedCaller>>,
835    #[serde(skip_serializing_if = "Option::is_none")]
836    pub allowed_domains: Option<Vec<String>>,
837    #[serde(skip_serializing_if = "Option::is_none")]
838    pub blocked_domains: Option<Vec<String>>,
839    #[serde(skip_serializing_if = "Option::is_none")]
840    pub cache_control: Option<CacheControl>,
841    #[serde(skip_serializing_if = "Option::is_none")]
842    pub defer_loading: Option<bool>,
843    #[serde(skip_serializing_if = "Option::is_none")]
844    pub max_uses: Option<i64>,
845    #[serde(skip_serializing_if = "Option::is_none")]
846    pub strict: Option<bool>,
847    #[serde(skip_serializing_if = "Option::is_none")]
848    pub user_location: Option<UserLocation>,
849    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
850    pub rest: Rest,
851}
852
853#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
854#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
855#[derive(gproxy_protocol_macros::DeclaredFields)]
856pub enum WebFetchTool20250910Name {
857    #[serde(rename = "web_fetch")]
858    Name,
859}
860
861#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
862#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
863#[derive(gproxy_protocol_macros::DeclaredFields)]
864pub enum WebFetchTool20250910Type {
865    #[serde(rename = "web_fetch_20250910")]
866    Tag,
867}
868#[derive(
869    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
870)]
871#[serde(rename_all = "snake_case")]
872#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
873#[derive(gproxy_protocol_macros::DeclaredFields)]
874pub struct WebFetchTool20250910 {
875    pub name: WebFetchTool20250910Name,
876    #[serde(rename = "type")]
877    pub type_: WebFetchTool20250910Type,
878    #[serde(skip_serializing_if = "Option::is_none")]
879    pub allowed_callers: Option<Vec<AllowedCaller>>,
880    #[serde(skip_serializing_if = "Option::is_none")]
881    pub allowed_domains: Option<Vec<String>>,
882    #[serde(skip_serializing_if = "Option::is_none")]
883    pub blocked_domains: Option<Vec<String>>,
884    #[serde(skip_serializing_if = "Option::is_none")]
885    pub cache_control: Option<CacheControl>,
886    #[serde(skip_serializing_if = "Option::is_none")]
887    pub citations: Option<CitationsConfig>,
888    #[serde(skip_serializing_if = "Option::is_none")]
889    pub defer_loading: Option<bool>,
890    #[serde(skip_serializing_if = "Option::is_none")]
891    pub max_content_tokens: Option<i64>,
892    #[serde(skip_serializing_if = "Option::is_none")]
893    pub max_uses: Option<i64>,
894    #[serde(skip_serializing_if = "Option::is_none")]
895    pub strict: Option<bool>,
896    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
897    pub rest: Rest,
898}
899
900#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
901#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
902#[derive(gproxy_protocol_macros::DeclaredFields)]
903pub enum WebSearchTool20260209Name {
904    #[serde(rename = "web_search")]
905    Name,
906}
907
908#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
909#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
910#[derive(gproxy_protocol_macros::DeclaredFields)]
911pub enum WebSearchTool20260209Type {
912    #[serde(rename = "web_search_20260209")]
913    Tag,
914}
915#[derive(
916    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
917)]
918#[serde(rename_all = "snake_case")]
919#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
920#[derive(gproxy_protocol_macros::DeclaredFields)]
921pub struct WebSearchTool20260209 {
922    pub name: WebSearchTool20260209Name,
923    #[serde(rename = "type")]
924    pub type_: WebSearchTool20260209Type,
925    #[serde(skip_serializing_if = "Option::is_none")]
926    pub allowed_callers: Option<Vec<AllowedCaller>>,
927    #[serde(skip_serializing_if = "Option::is_none")]
928    pub allowed_domains: Option<Vec<String>>,
929    #[serde(skip_serializing_if = "Option::is_none")]
930    pub blocked_domains: Option<Vec<String>>,
931    #[serde(skip_serializing_if = "Option::is_none")]
932    pub cache_control: Option<CacheControl>,
933    #[serde(skip_serializing_if = "Option::is_none")]
934    pub defer_loading: Option<bool>,
935    #[serde(skip_serializing_if = "Option::is_none")]
936    pub max_uses: Option<i64>,
937    #[serde(skip_serializing_if = "Option::is_none")]
938    pub strict: Option<bool>,
939    #[serde(skip_serializing_if = "Option::is_none")]
940    pub user_location: Option<UserLocation>,
941    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
942    pub rest: Rest,
943}
944
945#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
946#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
947#[derive(gproxy_protocol_macros::DeclaredFields)]
948pub enum WebFetchTool20260209Name {
949    #[serde(rename = "web_fetch")]
950    Name,
951}
952
953#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
954#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
955#[derive(gproxy_protocol_macros::DeclaredFields)]
956pub enum WebFetchTool20260209Type {
957    #[serde(rename = "web_fetch_20260209")]
958    Tag,
959}
960#[derive(
961    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
962)]
963#[serde(rename_all = "snake_case")]
964#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
965#[derive(gproxy_protocol_macros::DeclaredFields)]
966pub struct WebFetchTool20260209 {
967    pub name: WebFetchTool20260209Name,
968    #[serde(rename = "type")]
969    pub type_: WebFetchTool20260209Type,
970    #[serde(skip_serializing_if = "Option::is_none")]
971    pub allowed_callers: Option<Vec<AllowedCaller>>,
972    #[serde(skip_serializing_if = "Option::is_none")]
973    pub allowed_domains: Option<Vec<String>>,
974    #[serde(skip_serializing_if = "Option::is_none")]
975    pub blocked_domains: Option<Vec<String>>,
976    #[serde(skip_serializing_if = "Option::is_none")]
977    pub cache_control: Option<CacheControl>,
978    #[serde(skip_serializing_if = "Option::is_none")]
979    pub citations: Option<CitationsConfig>,
980    #[serde(skip_serializing_if = "Option::is_none")]
981    pub defer_loading: Option<bool>,
982    #[serde(skip_serializing_if = "Option::is_none")]
983    pub max_content_tokens: Option<i64>,
984    #[serde(skip_serializing_if = "Option::is_none")]
985    pub max_uses: Option<i64>,
986    #[serde(skip_serializing_if = "Option::is_none")]
987    pub strict: Option<bool>,
988    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
989    pub rest: Rest,
990}
991
992#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
993#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
994#[derive(gproxy_protocol_macros::DeclaredFields)]
995pub enum WebFetchTool20260309Name {
996    #[serde(rename = "web_fetch")]
997    Name,
998}
999
1000#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1001#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1002#[derive(gproxy_protocol_macros::DeclaredFields)]
1003pub enum WebFetchTool20260309Type {
1004    #[serde(rename = "web_fetch_20260309")]
1005    Tag,
1006}
1007#[derive(
1008    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1009)]
1010#[serde(rename_all = "snake_case")]
1011#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1012#[derive(gproxy_protocol_macros::DeclaredFields)]
1013pub struct WebFetchTool20260309 {
1014    pub name: WebFetchTool20260309Name,
1015    #[serde(rename = "type")]
1016    pub type_: WebFetchTool20260309Type,
1017    #[serde(skip_serializing_if = "Option::is_none")]
1018    pub allowed_callers: Option<Vec<AllowedCaller>>,
1019    #[serde(skip_serializing_if = "Option::is_none")]
1020    pub allowed_domains: Option<Vec<String>>,
1021    #[serde(skip_serializing_if = "Option::is_none")]
1022    pub blocked_domains: Option<Vec<String>>,
1023    #[serde(skip_serializing_if = "Option::is_none")]
1024    pub cache_control: Option<CacheControl>,
1025    #[serde(skip_serializing_if = "Option::is_none")]
1026    pub citations: Option<CitationsConfig>,
1027    #[serde(skip_serializing_if = "Option::is_none")]
1028    pub defer_loading: Option<bool>,
1029    #[serde(skip_serializing_if = "Option::is_none")]
1030    pub max_content_tokens: Option<i64>,
1031    #[serde(skip_serializing_if = "Option::is_none")]
1032    pub max_uses: Option<i64>,
1033    #[serde(skip_serializing_if = "Option::is_none")]
1034    pub strict: Option<bool>,
1035    #[serde(skip_serializing_if = "Option::is_none")]
1036    pub use_cache: Option<bool>,
1037    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1038    pub rest: Rest,
1039}
1040
1041#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1042#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1043#[derive(gproxy_protocol_macros::DeclaredFields)]
1044pub enum WebSearchTool20260318Name {
1045    #[serde(rename = "web_search")]
1046    Name,
1047}
1048
1049#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1050#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1051#[derive(gproxy_protocol_macros::DeclaredFields)]
1052pub enum WebSearchTool20260318Type {
1053    #[serde(rename = "web_search_20260318")]
1054    Tag,
1055}
1056#[derive(
1057    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1058)]
1059#[serde(rename_all = "snake_case")]
1060#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1061#[derive(gproxy_protocol_macros::DeclaredFields)]
1062pub struct WebSearchTool20260318 {
1063    pub name: WebSearchTool20260318Name,
1064    #[serde(rename = "type")]
1065    pub type_: WebSearchTool20260318Type,
1066    #[serde(skip_serializing_if = "Option::is_none")]
1067    pub allowed_callers: Option<Vec<AllowedCaller>>,
1068    #[serde(skip_serializing_if = "Option::is_none")]
1069    pub allowed_domains: Option<Vec<String>>,
1070    #[serde(skip_serializing_if = "Option::is_none")]
1071    pub blocked_domains: Option<Vec<String>>,
1072    #[serde(skip_serializing_if = "Option::is_none")]
1073    pub cache_control: Option<CacheControl>,
1074    #[serde(skip_serializing_if = "Option::is_none")]
1075    pub defer_loading: Option<bool>,
1076    #[serde(skip_serializing_if = "Option::is_none")]
1077    pub max_uses: Option<i64>,
1078    #[serde(skip_serializing_if = "Option::is_none")]
1079    pub response_inclusion: Option<ResponseInclusion>,
1080    #[serde(skip_serializing_if = "Option::is_none")]
1081    pub strict: Option<bool>,
1082    #[serde(skip_serializing_if = "Option::is_none")]
1083    pub user_location: Option<UserLocation>,
1084    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1085    pub rest: Rest,
1086}
1087
1088#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1089#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1090#[derive(gproxy_protocol_macros::DeclaredFields)]
1091pub enum WebFetchTool20260318Name {
1092    #[serde(rename = "web_fetch")]
1093    Name,
1094}
1095
1096#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1097#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1098#[derive(gproxy_protocol_macros::DeclaredFields)]
1099pub enum WebFetchTool20260318Type {
1100    #[serde(rename = "web_fetch_20260318")]
1101    Tag,
1102}
1103#[derive(
1104    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1105)]
1106#[serde(rename_all = "snake_case")]
1107#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1108#[derive(gproxy_protocol_macros::DeclaredFields)]
1109pub struct WebFetchTool20260318 {
1110    pub name: WebFetchTool20260318Name,
1111    #[serde(rename = "type")]
1112    pub type_: WebFetchTool20260318Type,
1113    #[serde(skip_serializing_if = "Option::is_none")]
1114    pub allowed_callers: Option<Vec<AllowedCaller>>,
1115    #[serde(skip_serializing_if = "Option::is_none")]
1116    pub allowed_domains: Option<Vec<String>>,
1117    #[serde(skip_serializing_if = "Option::is_none")]
1118    pub blocked_domains: Option<Vec<String>>,
1119    #[serde(skip_serializing_if = "Option::is_none")]
1120    pub cache_control: Option<CacheControl>,
1121    #[serde(skip_serializing_if = "Option::is_none")]
1122    pub citations: Option<CitationsConfig>,
1123    #[serde(skip_serializing_if = "Option::is_none")]
1124    pub defer_loading: Option<bool>,
1125    #[serde(skip_serializing_if = "Option::is_none")]
1126    pub max_content_tokens: Option<i64>,
1127    #[serde(skip_serializing_if = "Option::is_none")]
1128    pub max_uses: Option<i64>,
1129    #[serde(skip_serializing_if = "Option::is_none")]
1130    pub response_inclusion: Option<ResponseInclusion>,
1131    #[serde(skip_serializing_if = "Option::is_none")]
1132    pub strict: Option<bool>,
1133    #[serde(skip_serializing_if = "Option::is_none")]
1134    pub use_cache: Option<bool>,
1135    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1136    pub rest: Rest,
1137}
1138
1139#[derive(
1140    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1141)]
1142#[serde(rename_all = "snake_case")]
1143#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1144#[derive(gproxy_protocol_macros::DeclaredFields)]
1145pub struct AdvisorTool20260301 {
1146    pub name: AdvisorTool20260301Name,
1147    #[serde(rename = "type")]
1148    pub type_: AdvisorTool20260301Type,
1149    pub model: String,
1150    #[serde(skip_serializing_if = "Option::is_none")]
1151    pub allowed_callers: Option<Vec<AllowedCaller>>,
1152    #[serde(skip_serializing_if = "Option::is_none")]
1153    pub cache_control: Option<CacheControl>,
1154    #[serde(skip_serializing_if = "Option::is_none")]
1155    pub caching: Option<CacheControl>,
1156    #[serde(skip_serializing_if = "Option::is_none")]
1157    pub defer_loading: Option<bool>,
1158    #[serde(skip_serializing_if = "Option::is_none")]
1159    pub max_tokens: Option<i64>,
1160    #[serde(skip_serializing_if = "Option::is_none")]
1161    pub max_uses: Option<i64>,
1162    #[serde(skip_serializing_if = "Option::is_none")]
1163    pub strict: Option<bool>,
1164    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1165    pub rest: Rest,
1166}
1167
1168#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1169#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1170#[derive(gproxy_protocol_macros::DeclaredFields)]
1171pub enum ToolSearchBm25Tool20251119Name {
1172    #[serde(rename = "tool_search_tool_bm25")]
1173    Name,
1174}
1175
1176#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1177#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1178#[derive(gproxy_protocol_macros::DeclaredFields)]
1179pub enum ToolSearchBm25Tool20251119Type {
1180    #[serde(rename = "tool_search_tool_bm25_20251119")]
1181    Tag,
1182    #[serde(rename = "tool_search_tool_bm25")]
1183    Unversioned,
1184}
1185#[derive(
1186    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1187)]
1188#[serde(rename_all = "snake_case")]
1189#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1190#[derive(gproxy_protocol_macros::DeclaredFields)]
1191pub struct ToolSearchBm25Tool20251119 {
1192    pub name: ToolSearchBm25Tool20251119Name,
1193    #[serde(rename = "type")]
1194    pub type_: ToolSearchBm25Tool20251119Type,
1195    #[serde(skip_serializing_if = "Option::is_none")]
1196    pub allowed_callers: Option<Vec<AllowedCaller>>,
1197    #[serde(skip_serializing_if = "Option::is_none")]
1198    pub cache_control: Option<CacheControl>,
1199    #[serde(skip_serializing_if = "Option::is_none")]
1200    pub defer_loading: Option<bool>,
1201    #[serde(skip_serializing_if = "Option::is_none")]
1202    pub strict: Option<bool>,
1203    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1204    pub rest: Rest,
1205}
1206
1207#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1208#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1209#[derive(gproxy_protocol_macros::DeclaredFields)]
1210pub enum ToolSearchRegexTool20251119Name {
1211    #[serde(rename = "tool_search_tool_regex")]
1212    Name,
1213}
1214
1215#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1216#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1217#[derive(gproxy_protocol_macros::DeclaredFields)]
1218pub enum ToolSearchRegexTool20251119Type {
1219    #[serde(rename = "tool_search_tool_regex_20251119")]
1220    Tag,
1221    #[serde(rename = "tool_search_tool_regex")]
1222    Unversioned,
1223}
1224#[derive(
1225    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1226)]
1227#[serde(rename_all = "snake_case")]
1228#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1229#[derive(gproxy_protocol_macros::DeclaredFields)]
1230pub struct ToolSearchRegexTool20251119 {
1231    pub name: ToolSearchRegexTool20251119Name,
1232    #[serde(rename = "type")]
1233    pub type_: ToolSearchRegexTool20251119Type,
1234    #[serde(skip_serializing_if = "Option::is_none")]
1235    pub allowed_callers: Option<Vec<AllowedCaller>>,
1236    #[serde(skip_serializing_if = "Option::is_none")]
1237    pub cache_control: Option<CacheControl>,
1238    #[serde(skip_serializing_if = "Option::is_none")]
1239    pub defer_loading: Option<bool>,
1240    #[serde(skip_serializing_if = "Option::is_none")]
1241    pub strict: Option<bool>,
1242    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1243    pub rest: Rest,
1244}
1245
1246#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1247#[serde(rename_all = "snake_case")]
1248#[derive(gproxy_protocol_macros::DeclaredFields)]
1249pub enum ResponseInclusion {
1250    Full,
1251    Excluded,
1252}
1253#[derive(
1254    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1255)]
1256#[serde(rename_all = "snake_case")]
1257#[derive(gproxy_protocol_macros::DeclaredFields)]
1258pub struct UserLocation {
1259    #[serde(rename = "type")]
1260    pub type_: UserLocationType,
1261    #[serde(skip_serializing_if = "Option::is_none")]
1262    pub city: Option<String>,
1263    #[serde(skip_serializing_if = "Option::is_none")]
1264    pub country: Option<String>,
1265    #[serde(skip_serializing_if = "Option::is_none")]
1266    pub region: Option<String>,
1267    #[serde(skip_serializing_if = "Option::is_none")]
1268    pub timezone: Option<String>,
1269    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1270    pub rest: Rest,
1271}
1272#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1273#[serde(rename_all = "snake_case")]
1274#[derive(gproxy_protocol_macros::DeclaredFields)]
1275pub enum UserLocationType {
1276    Approximate,
1277}
1278
1279#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1280#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1281#[derive(gproxy_protocol_macros::DeclaredFields)]
1282pub enum AdvisorTool20260301Name {
1283    #[serde(rename = "advisor")]
1284    Name,
1285}
1286
1287#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1288#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1289#[derive(gproxy_protocol_macros::DeclaredFields)]
1290pub enum AdvisorTool20260301Type {
1291    #[serde(rename = "advisor_20260301")]
1292    Tag,
1293}
1294
1295#[derive(
1296    Debug,
1297    Clone,
1298    PartialEq,
1299    Eq,
1300    Serialize,
1301    Deserialize,
1302    gproxy_protocol_macros::WireBuilder,
1303    gproxy_protocol_macros::DeclaredFields,
1304)]
1305#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1306pub struct McpListedTool {
1307    pub name: String,
1308    #[serde(skip_serializing_if = "Option::is_none")]
1309    pub description: Option<String>,
1310    pub input_schema: JsonSchema,
1311    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1312    pub rest: Rest,
1313}
1314
1315#[derive(
1316    Debug,
1317    Clone,
1318    Copy,
1319    PartialEq,
1320    Eq,
1321    Serialize,
1322    Deserialize,
1323    gproxy_protocol_macros::DeclaredFields,
1324)]
1325#[serde(rename_all = "snake_case")]
1326#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1327pub enum BrowserToolset20260801Type {
1328    #[serde(rename = "browser_toolset_20260801")]
1329    Tag,
1330}
1331
1332#[derive(
1333    Debug,
1334    Clone,
1335    PartialEq,
1336    Eq,
1337    Serialize,
1338    Deserialize,
1339    gproxy_protocol_macros::WireBuilder,
1340    gproxy_protocol_macros::DeclaredFields,
1341)]
1342#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1343pub struct BrowserToolset20260801 {
1344    #[serde(rename = "type")]
1345    pub type_: BrowserToolset20260801Type,
1346    #[serde(skip_serializing_if = "Option::is_none")]
1347    pub cache_control: Option<CacheControl>,
1348    #[serde(skip_serializing_if = "Option::is_none")]
1349    pub configs: Option<BrowserToolsetConfigs>,
1350    #[serde(skip_serializing_if = "Option::is_none")]
1351    pub allowed_callers: Option<Vec<AllowedCaller>>,
1352    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1353    pub rest: Rest,
1354}
1355
1356#[derive(
1357    Debug,
1358    Clone,
1359    PartialEq,
1360    Eq,
1361    Serialize,
1362    Deserialize,
1363    gproxy_protocol_macros::WireBuilder,
1364    gproxy_protocol_macros::DeclaredFields,
1365)]
1366#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1367pub struct BrowserToolsetConfigs {
1368    #[serde(rename = "type")]
1369    #[serde(skip_serializing_if = "Option::is_none")]
1370    pub type_: Option<ToolsetMemberConfig>,
1371    #[serde(skip_serializing_if = "Option::is_none")]
1372    pub close_tab: Option<ToolsetMemberConfig>,
1373    #[serde(skip_serializing_if = "Option::is_none")]
1374    pub double_click: Option<ToolsetMemberConfig>,
1375    #[serde(skip_serializing_if = "Option::is_none")]
1376    pub file_upload: Option<ToolsetMemberConfig>,
1377    #[serde(skip_serializing_if = "Option::is_none")]
1378    pub find: Option<ToolsetMemberConfig>,
1379    #[serde(skip_serializing_if = "Option::is_none")]
1380    pub form_input: Option<ToolsetMemberConfig>,
1381    #[serde(skip_serializing_if = "Option::is_none")]
1382    pub get_page_text: Option<ToolsetMemberConfig>,
1383    #[serde(skip_serializing_if = "Option::is_none")]
1384    pub hold_key: Option<ToolsetMemberConfig>,
1385    #[serde(skip_serializing_if = "Option::is_none")]
1386    pub hover: Option<ToolsetMemberConfig>,
1387    #[serde(skip_serializing_if = "Option::is_none")]
1388    pub javascript_exec: Option<ToolsetMemberConfig>,
1389    #[serde(skip_serializing_if = "Option::is_none")]
1390    pub key: Option<ToolsetMemberConfig>,
1391    #[serde(skip_serializing_if = "Option::is_none")]
1392    pub left_click: Option<ToolsetMemberConfig>,
1393    #[serde(skip_serializing_if = "Option::is_none")]
1394    pub left_click_drag: Option<ToolsetMemberConfig>,
1395    #[serde(skip_serializing_if = "Option::is_none")]
1396    pub left_mouse_down: Option<ToolsetMemberConfig>,
1397    #[serde(skip_serializing_if = "Option::is_none")]
1398    pub left_mouse_up: Option<ToolsetMemberConfig>,
1399    #[serde(skip_serializing_if = "Option::is_none")]
1400    pub list_tabs: Option<ToolsetMemberConfig>,
1401    #[serde(skip_serializing_if = "Option::is_none")]
1402    pub middle_click: Option<ToolsetMemberConfig>,
1403    #[serde(skip_serializing_if = "Option::is_none")]
1404    pub mouse_move: Option<ToolsetMemberConfig>,
1405    #[serde(skip_serializing_if = "Option::is_none")]
1406    pub navigate: Option<ToolsetMemberConfig>,
1407    #[serde(skip_serializing_if = "Option::is_none")]
1408    pub new_tab: Option<ToolsetMemberConfig>,
1409    #[serde(skip_serializing_if = "Option::is_none")]
1410    pub read_console: Option<ToolsetMemberConfig>,
1411    #[serde(skip_serializing_if = "Option::is_none")]
1412    pub read_network: Option<ToolsetMemberConfig>,
1413    #[serde(skip_serializing_if = "Option::is_none")]
1414    pub read_page: Option<ToolsetMemberConfig>,
1415    #[serde(skip_serializing_if = "Option::is_none")]
1416    pub right_click: Option<ToolsetMemberConfig>,
1417    #[serde(skip_serializing_if = "Option::is_none")]
1418    pub screenshot: Option<ToolsetMemberConfig>,
1419    #[serde(skip_serializing_if = "Option::is_none")]
1420    pub scroll: Option<ToolsetMemberConfig>,
1421    #[serde(skip_serializing_if = "Option::is_none")]
1422    pub scroll_to: Option<ToolsetMemberConfig>,
1423    #[serde(skip_serializing_if = "Option::is_none")]
1424    pub switch_tab: Option<ToolsetMemberConfig>,
1425    #[serde(skip_serializing_if = "Option::is_none")]
1426    pub triple_click: Option<ToolsetMemberConfig>,
1427    #[serde(skip_serializing_if = "Option::is_none")]
1428    pub wait: Option<ToolsetMemberConfig>,
1429    #[serde(skip_serializing_if = "Option::is_none")]
1430    pub zoom: Option<ToolsetMemberConfig>,
1431    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1432    pub rest: Rest,
1433}
1434
1435#[derive(
1436    Debug,
1437    Clone,
1438    Copy,
1439    PartialEq,
1440    Eq,
1441    Serialize,
1442    Deserialize,
1443    gproxy_protocol_macros::DeclaredFields,
1444)]
1445#[serde(rename_all = "snake_case")]
1446#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1447pub enum ComputerToolset20260801Type {
1448    #[serde(rename = "computer_toolset_20260801")]
1449    Tag,
1450}
1451
1452#[derive(
1453    Debug,
1454    Clone,
1455    PartialEq,
1456    Eq,
1457    Serialize,
1458    Deserialize,
1459    gproxy_protocol_macros::WireBuilder,
1460    gproxy_protocol_macros::DeclaredFields,
1461)]
1462#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1463pub struct ComputerToolset20260801 {
1464    #[serde(rename = "type")]
1465    pub type_: ComputerToolset20260801Type,
1466    #[serde(skip_serializing_if = "Option::is_none")]
1467    pub cache_control: Option<CacheControl>,
1468    #[serde(skip_serializing_if = "Option::is_none")]
1469    pub configs: Option<ComputerToolsetConfigs>,
1470    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1471    pub rest: Rest,
1472}
1473
1474#[derive(
1475    Debug,
1476    Clone,
1477    PartialEq,
1478    Eq,
1479    Serialize,
1480    Deserialize,
1481    gproxy_protocol_macros::WireBuilder,
1482    gproxy_protocol_macros::DeclaredFields,
1483)]
1484#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1485pub struct ComputerToolsetConfigs {
1486    #[serde(rename = "type")]
1487    #[serde(skip_serializing_if = "Option::is_none")]
1488    pub type_: Option<ToolsetMemberConfig>,
1489    #[serde(skip_serializing_if = "Option::is_none")]
1490    pub cursor_position: Option<ToolsetMemberConfig>,
1491    #[serde(skip_serializing_if = "Option::is_none")]
1492    pub double_click: Option<ToolsetMemberConfig>,
1493    #[serde(skip_serializing_if = "Option::is_none")]
1494    pub hold_key: Option<ToolsetMemberConfig>,
1495    #[serde(skip_serializing_if = "Option::is_none")]
1496    pub key: Option<ToolsetMemberConfig>,
1497    #[serde(skip_serializing_if = "Option::is_none")]
1498    pub left_click: Option<ToolsetMemberConfig>,
1499    #[serde(skip_serializing_if = "Option::is_none")]
1500    pub left_click_drag: Option<ToolsetMemberConfig>,
1501    #[serde(skip_serializing_if = "Option::is_none")]
1502    pub left_mouse_down: Option<ToolsetMemberConfig>,
1503    #[serde(skip_serializing_if = "Option::is_none")]
1504    pub left_mouse_up: Option<ToolsetMemberConfig>,
1505    #[serde(skip_serializing_if = "Option::is_none")]
1506    pub middle_click: Option<ToolsetMemberConfig>,
1507    #[serde(skip_serializing_if = "Option::is_none")]
1508    pub mouse_move: Option<ToolsetMemberConfig>,
1509    #[serde(skip_serializing_if = "Option::is_none")]
1510    pub right_click: Option<ToolsetMemberConfig>,
1511    #[serde(skip_serializing_if = "Option::is_none")]
1512    pub screenshot: Option<ToolsetMemberConfig>,
1513    #[serde(skip_serializing_if = "Option::is_none")]
1514    pub scroll: Option<ToolsetMemberConfig>,
1515    #[serde(skip_serializing_if = "Option::is_none")]
1516    pub triple_click: Option<ToolsetMemberConfig>,
1517    #[serde(skip_serializing_if = "Option::is_none")]
1518    pub wait: Option<ToolsetMemberConfig>,
1519    #[serde(skip_serializing_if = "Option::is_none")]
1520    pub zoom: Option<ToolsetMemberConfig>,
1521    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1522    pub rest: Rest,
1523}
1524
1525#[derive(
1526    Debug,
1527    Clone,
1528    PartialEq,
1529    Eq,
1530    Serialize,
1531    Deserialize,
1532    gproxy_protocol_macros::WireBuilder,
1533    gproxy_protocol_macros::DeclaredFields,
1534)]
1535#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
1536pub struct ToolsetMemberConfig {
1537    #[serde(skip_serializing_if = "Option::is_none")]
1538    pub enabled: Option<bool>,
1539    #[serde(skip_serializing_if = "Option::is_none")]
1540    pub defer_loading: Option<bool>,
1541    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1542    pub rest: Rest,
1543}
gproxy_protocol/wire/claude/tools.rs

gproxy_protocol/wire/claude/
tools.rs
