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

gproxy_protocol/wire/claude/
tools.rs
