gproxy_protocol/wire/openai/responses/
tools.rs

1//! Native OpenAI Responses tool definitions and their configuration objects.
2
3use crate::Rest;
4use serde::{Deserialize, Serialize};
5
6use super::input::{present_nullable, required_nullable};
7
8#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
9#[serde(tag = "type")]
10#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
11#[derive(gproxy_protocol_macros::DeclaredFields)]
12pub enum Tool {
13    #[serde(rename = "function")]
14    Function(FunctionTool),
15    #[serde(rename = "file_search")]
16    FileSearch(FileSearchTool),
17    #[serde(rename = "computer_use_preview")]
18    Computer(ComputerTool),
19    #[serde(rename = "computer")]
20    ComputerHosted(ToolMarker),
21    #[serde(rename = "web_search_preview")]
22    WebSearch(WebSearchPreviewTool),
23    #[serde(rename = "web_search_preview_2025_03_11")]
24    WebSearchPreview20250311(WebSearchPreviewTool),
25    #[serde(rename = "web_search")]
26    WebSearchLegacy(WebSearchTool),
27    #[serde(rename = "web_search_2025_08_26")]
28    WebSearch2025(WebSearchTool),
29    #[serde(rename = "code_interpreter")]
30    CodeInterpreter(CodeInterpreterTool),
31    #[serde(rename = "custom")]
32    Custom(CustomTool),
33    #[serde(rename = "namespace")]
34    Namespace(NamespaceTool),
35    #[serde(rename = "local_shell")]
36    LocalShell(ToolMarker),
37    #[serde(rename = "shell")]
38    Shell(ShellTool),
39    #[serde(rename = "image_generation")]
40    ImageGeneration(ImageGenerationTool),
41    #[serde(rename = "mcp")]
42    Mcp(McpTool),
43    #[serde(rename = "programmatic_tool_calling")]
44    Programmatic(ToolMarker),
45    #[serde(rename = "apply_patch")]
46    ApplyPatch(ApplyPatchTool),
47    #[serde(rename = "tool_search")]
48    ToolSearch(ToolSearchTool),
49}
50#[derive(
51    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
52)]
53#[serde(rename_all = "snake_case")]
54#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
55#[derive(gproxy_protocol_macros::DeclaredFields)]
56pub struct FunctionTool {
57    #[serde(rename = "async", skip_serializing_if = "Option::is_none")]
58    pub async_: Option<bool>,
59
60    pub name: String,
61    #[wire(required)]
62    #[serde(deserialize_with = "required_nullable")]
63    pub parameters: Option<Rest>,
64    #[wire(required)]
65    #[serde(deserialize_with = "required_nullable")]
66    pub strict: Option<bool>,
67    #[serde(
68        default,
69        deserialize_with = "present_nullable",
70        skip_serializing_if = "Option::is_none"
71    )]
72    pub description: Option<Option<String>>,
73    #[serde(
74        default,
75        deserialize_with = "present_nullable",
76        skip_serializing_if = "Option::is_none"
77    )]
78    pub allowed_callers: Option<Option<Vec<AllowedCaller>>>,
79    #[serde(skip_serializing_if = "Option::is_none")]
80    pub defer_loading: Option<bool>,
81    #[serde(
82        default,
83        deserialize_with = "present_nullable",
84        skip_serializing_if = "Option::is_none"
85    )]
86    pub output_schema: Option<Option<Rest>>,
87    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
88    pub rest: Rest,
89}
90#[derive(
91    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
92)]
93#[serde(rename_all = "snake_case")]
94#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
95#[derive(gproxy_protocol_macros::DeclaredFields)]
96pub struct FileSearchTool {
97    pub vector_store_ids: Vec<String>,
98    #[serde(
99        default,
100        deserialize_with = "present_nullable",
101        skip_serializing_if = "Option::is_none"
102    )]
103    pub filters: Option<Option<FileSearchFilter>>,
104    #[serde(skip_serializing_if = "Option::is_none")]
105    pub max_num_results: Option<serde_json::Number>,
106    #[serde(skip_serializing_if = "Option::is_none")]
107    pub ranking_options: Option<RankingOptions>,
108    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
109    pub rest: Rest,
110}
111#[derive(
112    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
113)]
114#[serde(rename_all = "snake_case")]
115#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
116#[derive(gproxy_protocol_macros::DeclaredFields)]
117pub struct ComputerTool {
118    pub display_height: i64,
119    pub display_width: i64,
120    pub environment: ComputerEnvironment,
121    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
122    pub rest: Rest,
123}
124#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
125#[serde(rename_all = "snake_case")]
126#[derive(gproxy_protocol_macros::DeclaredFields)]
127pub enum ComputerEnvironment {
128    Windows,
129    Mac,
130    Linux,
131    Ubuntu,
132    Browser,
133}
134#[derive(
135    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
136)]
137#[serde(rename_all = "snake_case")]
138#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
139#[derive(gproxy_protocol_macros::DeclaredFields)]
140pub struct WebSearchTool {
141    #[serde(
142        default,
143        deserialize_with = "present_nullable",
144        skip_serializing_if = "Option::is_none"
145    )]
146    pub filters: Option<Option<WebSearchFilters>>,
147    #[serde(skip_serializing_if = "Option::is_none")]
148    pub search_context_size: Option<SearchContextSize>,
149    #[serde(
150        default,
151        deserialize_with = "present_nullable",
152        skip_serializing_if = "Option::is_none"
153    )]
154    pub user_location: Option<Option<UserLocation>>,
155    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
156    pub rest: Rest,
157}
158#[derive(
159    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
160)]
161#[serde(rename_all = "snake_case")]
162#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
163#[derive(gproxy_protocol_macros::DeclaredFields)]
164pub struct WebSearchPreviewTool {
165    #[serde(skip_serializing_if = "Option::is_none")]
166    pub search_context_size: Option<SearchContextSize>,
167    #[serde(skip_serializing_if = "Option::is_none")]
168    pub search_content_types: Option<Vec<SearchContentType>>,
169    #[serde(
170        default,
171        deserialize_with = "present_nullable",
172        skip_serializing_if = "Option::is_none"
173    )]
174    pub user_location: Option<Option<PreviewUserLocation>>,
175    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
176    pub rest: Rest,
177}
178#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
179#[serde(rename_all = "snake_case")]
180#[derive(gproxy_protocol_macros::DeclaredFields)]
181pub enum SearchContextSize {
182    Low,
183    Medium,
184    High,
185}
186#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
187#[serde(rename_all = "snake_case")]
188#[derive(gproxy_protocol_macros::DeclaredFields)]
189pub enum SearchContentType {
190    Text,
191    Image,
192}
193#[derive(
194    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
195)]
196#[serde(rename_all = "snake_case")]
197#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
198#[derive(gproxy_protocol_macros::DeclaredFields)]
199pub struct CodeInterpreterTool {
200    pub container: CodeInterpreterContainer,
201    #[serde(
202        default,
203        deserialize_with = "present_nullable",
204        skip_serializing_if = "Option::is_none"
205    )]
206    pub allowed_callers: Option<Option<Vec<AllowedCaller>>>,
207    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
208    pub rest: Rest,
209}
210#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
211#[serde(untagged)]
212#[derive(gproxy_protocol_macros::DeclaredFields)]
213pub enum CodeInterpreterContainer {
214    Id(String),
215    Auto(CodeInterpreterAuto),
216}
217#[derive(
218    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
219)]
220#[serde(rename_all = "snake_case")]
221#[derive(gproxy_protocol_macros::DeclaredFields)]
222pub struct CodeInterpreterAuto {
223    #[serde(rename = "type")]
224    pub type_: AutoContainerType,
225    #[serde(skip_serializing_if = "Option::is_none")]
226    pub file_ids: Option<Vec<String>>,
227    #[serde(
228        default,
229        deserialize_with = "present_nullable",
230        skip_serializing_if = "Option::is_none"
231    )]
232    pub memory_limit: Option<Option<MemoryLimit>>,
233    #[serde(skip_serializing_if = "Option::is_none")]
234    pub network_policy: Option<ContainerNetworkPolicy>,
235    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
236    pub rest: Rest,
237}
238#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
239#[serde(rename_all = "snake_case")]
240#[derive(gproxy_protocol_macros::DeclaredFields)]
241pub enum AutoContainerType {
242    Auto,
243}
244#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
245#[serde(rename_all = "snake_case")]
246#[derive(gproxy_protocol_macros::DeclaredFields)]
247pub enum MemoryLimit {
248    #[serde(rename = "1g")]
249    OneG,
250    #[serde(rename = "4g")]
251    FourG,
252    #[serde(rename = "16g")]
253    SixteenG,
254    #[serde(rename = "64g")]
255    SixtyFourG,
256}
257#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
258#[serde(untagged)]
259#[derive(gproxy_protocol_macros::DeclaredFields)]
260pub enum ContainerNetworkPolicy {
261    Disabled(NetworkDisabled),
262    Allowlist(NetworkAllowlist),
263}
264#[derive(
265    Debug,
266    Clone,
267    PartialEq,
268    Eq,
269    Serialize,
270    Deserialize,
271    gproxy_protocol_macros::WireBuilder,
272    gproxy_protocol_macros::DeclaredFields,
273)]
274pub struct NetworkDisabled {
275    #[serde(rename = "type")]
276    pub type_: NetworkDisabledType,
277    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
278    pub rest: Rest,
279}
280#[derive(
281    Debug,
282    Clone,
283    Copy,
284    PartialEq,
285    Eq,
286    Serialize,
287    Deserialize,
288    gproxy_protocol_macros::DeclaredFields,
289)]
290pub enum NetworkDisabledType {
291    #[serde(rename = "disabled")]
292    Disabled,
293}
294#[derive(
295    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
296)]
297#[serde(rename_all = "snake_case")]
298#[derive(gproxy_protocol_macros::DeclaredFields)]
299pub struct NetworkAllowlist {
300    pub allowed_domains: Vec<String>,
301    #[serde(rename = "type")]
302    pub type_: NetworkAllowlistType,
303    #[serde(skip_serializing_if = "Option::is_none")]
304    pub domain_secrets: Option<Vec<DomainSecret>>,
305    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
306    pub rest: Rest,
307}
308#[derive(
309    Debug,
310    Clone,
311    Copy,
312    PartialEq,
313    Eq,
314    Serialize,
315    Deserialize,
316    gproxy_protocol_macros::DeclaredFields,
317)]
318pub enum NetworkAllowlistType {
319    #[serde(rename = "allowlist")]
320    Allowlist,
321}
322#[derive(
323    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
324)]
325#[serde(rename_all = "snake_case")]
326#[derive(gproxy_protocol_macros::DeclaredFields)]
327pub struct DomainSecret {
328    pub domain: String,
329    pub name: String,
330    pub value: String,
331    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
332    pub rest: Rest,
333}
334#[derive(
335    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
336)]
337#[serde(rename_all = "snake_case")]
338#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
339#[derive(gproxy_protocol_macros::DeclaredFields)]
340pub struct CustomTool {
341    #[serde(rename = "async", skip_serializing_if = "Option::is_none")]
342    pub async_: Option<bool>,
343
344    pub name: String,
345    #[serde(skip_serializing_if = "Option::is_none")]
346    pub description: Option<String>,
347    #[serde(skip_serializing_if = "Option::is_none")]
348    pub format: Option<CustomToolFormat>,
349    #[serde(
350        default,
351        deserialize_with = "present_nullable",
352        skip_serializing_if = "Option::is_none"
353    )]
354    pub allowed_callers: Option<Option<Vec<AllowedCaller>>>,
355    #[serde(skip_serializing_if = "Option::is_none")]
356    pub defer_loading: Option<bool>,
357    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
358    pub rest: Rest,
359}
360#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
361#[serde(untagged)]
362#[derive(gproxy_protocol_macros::DeclaredFields)]
363pub enum CustomToolFormat {
364    Text(CustomTextFormat),
365    Grammar(GrammarFormat),
366}
367#[derive(
368    Debug,
369    Clone,
370    PartialEq,
371    Eq,
372    Serialize,
373    Deserialize,
374    gproxy_protocol_macros::WireBuilder,
375    gproxy_protocol_macros::DeclaredFields,
376)]
377pub struct CustomTextFormat {
378    #[serde(rename = "type")]
379    pub type_: TextFormatType,
380    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
381    pub rest: Rest,
382}
383#[derive(
384    Debug,
385    Clone,
386    Copy,
387    PartialEq,
388    Eq,
389    Serialize,
390    Deserialize,
391    gproxy_protocol_macros::DeclaredFields,
392)]
393pub enum TextFormatType {
394    #[serde(rename = "text")]
395    Text,
396}
397#[derive(
398    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
399)]
400#[serde(rename_all = "snake_case")]
401#[derive(gproxy_protocol_macros::DeclaredFields)]
402pub struct GrammarFormat {
403    pub definition: String,
404    pub syntax: GrammarSyntax,
405    #[serde(rename = "type")]
406    pub type_: GrammarFormatType,
407    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
408    pub rest: Rest,
409}
410#[derive(
411    Debug,
412    Clone,
413    Copy,
414    PartialEq,
415    Eq,
416    Serialize,
417    Deserialize,
418    gproxy_protocol_macros::DeclaredFields,
419)]
420pub enum GrammarFormatType {
421    #[serde(rename = "grammar")]
422    Grammar,
423}
424#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
425#[serde(rename_all = "snake_case")]
426#[derive(gproxy_protocol_macros::DeclaredFields)]
427pub enum GrammarSyntax {
428    Lark,
429    Regex,
430}
431#[derive(
432    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
433)]
434#[serde(rename_all = "snake_case")]
435#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
436#[derive(gproxy_protocol_macros::DeclaredFields)]
437pub struct NamespaceTool {
438    pub description: String,
439    pub name: String,
440    pub tools: Vec<NamespaceToolDefinition>,
441    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
442    pub rest: Rest,
443}
444#[derive(
445    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
446)]
447#[serde(rename_all = "snake_case")]
448#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
449#[derive(gproxy_protocol_macros::DeclaredFields)]
450pub struct ToolMarker {
451    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
452    pub rest: Rest,
453}
454#[derive(
455    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
456)]
457#[serde(rename_all = "snake_case")]
458#[derive(gproxy_protocol_macros::DeclaredFields)]
459pub struct ApplyPatchTool {
460    #[serde(
461        default,
462        deserialize_with = "present_nullable",
463        skip_serializing_if = "Option::is_none"
464    )]
465    pub allowed_callers: Option<Option<Vec<AllowedCaller>>>,
466    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
467    pub rest: Rest,
468}
469#[derive(
470    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
471)]
472#[serde(rename_all = "snake_case")]
473#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
474#[derive(gproxy_protocol_macros::DeclaredFields)]
475pub struct ShellTool {
476    #[serde(
477        default,
478        deserialize_with = "present_nullable",
479        skip_serializing_if = "Option::is_none"
480    )]
481    pub allowed_callers: Option<Option<Vec<AllowedCaller>>>,
482    #[serde(
483        default,
484        deserialize_with = "present_nullable",
485        skip_serializing_if = "Option::is_none"
486    )]
487    pub environment: Option<Option<ShellEnvironment>>,
488    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
489    pub rest: Rest,
490}
491#[derive(
492    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
493)]
494#[serde(rename_all = "snake_case")]
495#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
496#[derive(gproxy_protocol_macros::DeclaredFields)]
497pub struct ImageGenerationTool {
498    #[serde(skip_serializing_if = "Option::is_none")]
499    pub action: Option<ImageAction>,
500    #[serde(
501        default,
502        deserialize_with = "present_nullable",
503        skip_serializing_if = "Option::is_none"
504    )]
505    pub input_fidelity: Option<Option<InputFidelity>>,
506    #[serde(skip_serializing_if = "Option::is_none")]
507    pub input_image_mask: Option<InputImageMask>,
508    #[serde(skip_serializing_if = "Option::is_none")]
509    pub moderation: Option<Moderation>,
510    #[serde(skip_serializing_if = "Option::is_none")]
511    pub background: Option<ImageBackground>,
512    #[serde(skip_serializing_if = "Option::is_none")]
513    pub model: Option<String>,
514    #[serde(skip_serializing_if = "Option::is_none")]
515    pub output_format: Option<ImageOutputFormat>,
516    #[serde(skip_serializing_if = "Option::is_none")]
517    pub output_compression: Option<serde_json::Number>,
518    #[serde(skip_serializing_if = "Option::is_none")]
519    pub partial_images: Option<i64>,
520    #[serde(skip_serializing_if = "Option::is_none")]
521    pub quality: Option<ImageQuality>,
522    #[serde(skip_serializing_if = "Option::is_none")]
523    pub size: Option<String>,
524    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
525    pub rest: Rest,
526}
527#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
528#[serde(rename_all = "snake_case")]
529#[derive(gproxy_protocol_macros::DeclaredFields)]
530pub enum InputFidelity {
531    Low,
532    High,
533}
534#[derive(
535    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
536)]
537#[serde(rename_all = "snake_case")]
538#[derive(gproxy_protocol_macros::DeclaredFields)]
539pub struct InputImageMask {
540    #[serde(skip_serializing_if = "Option::is_none")]
541    pub file_id: Option<String>,
542    #[serde(skip_serializing_if = "Option::is_none")]
543    pub image_url: Option<String>,
544    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
545    pub rest: Rest,
546}
547#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
548#[serde(rename_all = "snake_case")]
549#[derive(gproxy_protocol_macros::DeclaredFields)]
550pub enum Moderation {
551    Auto,
552    Low,
553}
554#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
555#[serde(rename_all = "snake_case")]
556#[derive(gproxy_protocol_macros::DeclaredFields)]
557pub enum ImageAction {
558    Generate,
559    Edit,
560    Auto,
561}
562#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
563#[serde(rename_all = "snake_case")]
564#[derive(gproxy_protocol_macros::DeclaredFields)]
565pub enum ImageBackground {
566    Transparent,
567    Opaque,
568    Auto,
569}
570#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
571#[serde(rename_all = "snake_case")]
572#[derive(gproxy_protocol_macros::DeclaredFields)]
573pub enum ImageOutputFormat {
574    Png,
575    Webp,
576    Jpeg,
577}
578#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
579#[serde(rename_all = "snake_case")]
580#[derive(gproxy_protocol_macros::DeclaredFields)]
581pub enum ImageQuality {
582    Xhigh,
583    Max,
584    Low,
585    Medium,
586    High,
587    Auto,
588}
589#[derive(
590    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
591)]
592#[serde(rename_all = "snake_case")]
593#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
594#[derive(gproxy_protocol_macros::DeclaredFields)]
595pub struct McpTool {
596    pub server_label: String,
597    #[serde(
598        default,
599        deserialize_with = "present_nullable",
600        skip_serializing_if = "Option::is_none"
601    )]
602    pub allowed_callers: Option<Option<Vec<AllowedCaller>>>,
603    #[serde(
604        default,
605        deserialize_with = "present_nullable",
606        skip_serializing_if = "Option::is_none"
607    )]
608    pub allowed_tools: Option<Option<McpAllowedTools>>,
609    #[serde(skip_serializing_if = "Option::is_none")]
610    pub authorization: Option<String>,
611    #[serde(skip_serializing_if = "Option::is_none")]
612    pub connector_id: Option<ConnectorId>,
613    #[serde(skip_serializing_if = "Option::is_none")]
614    pub defer_loading: Option<bool>,
615    #[serde(
616        default,
617        deserialize_with = "present_nullable",
618        skip_serializing_if = "Option::is_none"
619    )]
620    pub headers: Option<Option<std::collections::BTreeMap<String, String>>>,
621    #[serde(
622        default,
623        deserialize_with = "present_nullable",
624        skip_serializing_if = "Option::is_none"
625    )]
626    pub require_approval: Option<Option<McpApproval>>,
627    #[serde(skip_serializing_if = "Option::is_none")]
628    pub server_description: Option<String>,
629    #[serde(skip_serializing_if = "Option::is_none")]
630    pub server_url: Option<String>,
631    #[serde(skip_serializing_if = "Option::is_none")]
632    pub tunnel_id: Option<String>,
633    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
634    pub rest: Rest,
635}
636#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
637#[serde(untagged)]
638#[derive(gproxy_protocol_macros::DeclaredFields)]
639pub enum McpAllowedTools {
640    Names(Vec<String>),
641    Filter(McpToolFilter),
642}
643#[derive(
644    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
645)]
646#[serde(rename_all = "snake_case")]
647#[derive(gproxy_protocol_macros::DeclaredFields)]
648pub struct McpToolFilter {
649    #[serde(skip_serializing_if = "Option::is_none")]
650    pub read_only: Option<bool>,
651    #[serde(skip_serializing_if = "Option::is_none")]
652    pub tool_names: Option<Vec<String>>,
653    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
654    pub rest: Rest,
655}
656#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
657#[serde(untagged)]
658#[derive(gproxy_protocol_macros::DeclaredFields)]
659pub enum McpApproval {
660    Setting(McpApprovalSetting),
661    Filter(McpToolApprovalFilter),
662}
663#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
664#[serde(rename_all = "snake_case")]
665#[derive(gproxy_protocol_macros::DeclaredFields)]
666pub enum McpApprovalSetting {
667    Always,
668    Never,
669}
670#[derive(
671    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
672)]
673#[serde(rename_all = "snake_case")]
674#[derive(gproxy_protocol_macros::DeclaredFields)]
675pub struct McpToolApprovalFilter {
676    #[serde(skip_serializing_if = "Option::is_none")]
677    pub always: Option<McpToolFilter>,
678    #[serde(skip_serializing_if = "Option::is_none")]
679    pub never: Option<McpToolFilter>,
680    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
681    pub rest: Rest,
682}
683#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
684#[serde(rename_all = "snake_case")]
685#[derive(gproxy_protocol_macros::DeclaredFields)]
686pub enum ConnectorId {
687    ConnectorDropbox,
688    ConnectorGmail,
689    ConnectorGooglecalendar,
690    ConnectorGoogledrive,
691    ConnectorMicrosoftteams,
692    ConnectorOutlookcalendar,
693    ConnectorOutlookemail,
694    ConnectorSharepoint,
695}
696#[derive(
697    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
698)]
699#[serde(rename_all = "snake_case")]
700#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
701#[derive(gproxy_protocol_macros::DeclaredFields)]
702pub struct ToolSearchTool {
703    #[serde(
704        default,
705        deserialize_with = "present_nullable",
706        skip_serializing_if = "Option::is_none"
707    )]
708    pub description: Option<Option<String>>,
709    #[serde(skip_serializing_if = "Option::is_none")]
710    pub execution: Option<ToolExecution>,
711    #[serde(
712        default,
713        deserialize_with = "present_nullable",
714        skip_serializing_if = "Option::is_none"
715    )]
716    pub parameters: Option<Option<serde_json::Value>>,
717    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
718    pub rest: Rest,
719}
720#[derive(
721    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::DeclaredFields,
722)]
723pub enum ToolExecution {
724    #[serde(rename = "server")]
725    Server,
726    #[serde(rename = "client")]
727    Client,
728}
729
730#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
731#[serde(untagged)]
732#[derive(gproxy_protocol_macros::DeclaredFields)]
733pub enum FileSearchFilter {
734    Comparison(ComparisonFilter),
735    Compound(CompoundFilter),
736}
737#[derive(
738    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
739)]
740#[serde(rename_all = "snake_case")]
741#[derive(gproxy_protocol_macros::DeclaredFields)]
742pub struct ComparisonFilter {
743    pub key: String,
744    pub value: FilterValue,
745    #[serde(rename = "type")]
746    pub type_: ComparisonFilterType,
747    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
748    pub rest: Rest,
749}
750#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
751#[serde(untagged)]
752#[derive(gproxy_protocol_macros::DeclaredFields)]
753pub enum FilterValue {
754    String(String),
755    Number(serde_json::Number),
756    Boolean(bool),
757    Array(Vec<FilterArrayValue>),
758}
759#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
760#[serde(untagged)]
761#[derive(gproxy_protocol_macros::DeclaredFields)]
762pub enum FilterArrayValue {
763    String(String),
764    Number(serde_json::Number),
765}
766#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
767#[serde(rename_all = "snake_case")]
768#[derive(gproxy_protocol_macros::DeclaredFields)]
769pub enum ComparisonFilterType {
770    Eq,
771    Ne,
772    Gt,
773    Gte,
774    Lt,
775    Lte,
776    In,
777    Nin,
778}
779#[derive(
780    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
781)]
782#[serde(rename_all = "snake_case")]
783#[derive(gproxy_protocol_macros::DeclaredFields)]
784pub struct CompoundFilter {
785    pub filters: Vec<FileSearchFilter>,
786    #[serde(rename = "type")]
787    pub type_: CompoundFilterType,
788    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
789    pub rest: Rest,
790}
791#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
792#[serde(rename_all = "snake_case")]
793#[derive(gproxy_protocol_macros::DeclaredFields)]
794pub enum CompoundFilterType {
795    And,
796    Or,
797}
798#[derive(
799    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
800)]
801#[serde(rename_all = "snake_case")]
802#[derive(gproxy_protocol_macros::DeclaredFields)]
803pub struct RankingOptions {
804    #[serde(skip_serializing_if = "Option::is_none")]
805    pub hybrid_search: Option<HybridSearch>,
806    #[serde(skip_serializing_if = "Option::is_none")]
807    pub ranker: Option<Ranker>,
808    #[serde(skip_serializing_if = "Option::is_none")]
809    pub score_threshold: Option<serde_json::Number>,
810    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
811    pub rest: Rest,
812}
813#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
814#[serde(rename_all = "snake_case")]
815#[derive(gproxy_protocol_macros::DeclaredFields)]
816pub enum Ranker {
817    Auto,
818    #[serde(rename = "default-2024-11-15")]
819    Default20241115,
820}
821#[derive(
822    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
823)]
824#[serde(rename_all = "snake_case")]
825#[derive(gproxy_protocol_macros::DeclaredFields)]
826pub struct HybridSearch {
827    pub embedding_weight: serde_json::Number,
828    pub text_weight: serde_json::Number,
829    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
830    pub rest: Rest,
831}
832#[derive(
833    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
834)]
835#[serde(rename_all = "snake_case")]
836#[derive(gproxy_protocol_macros::DeclaredFields)]
837pub struct WebSearchFilters {
838    #[serde(
839        default,
840        deserialize_with = "present_nullable",
841        skip_serializing_if = "Option::is_none"
842    )]
843    pub allowed_domains: Option<Option<Vec<String>>>,
844    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
845    pub rest: Rest,
846}
847#[derive(
848    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
849)]
850#[serde(rename_all = "snake_case")]
851#[derive(gproxy_protocol_macros::DeclaredFields)]
852pub struct UserLocation {
853    #[serde(
854        default,
855        deserialize_with = "present_nullable",
856        skip_serializing_if = "Option::is_none"
857    )]
858    pub city: Option<Option<String>>,
859    #[serde(
860        default,
861        deserialize_with = "present_nullable",
862        skip_serializing_if = "Option::is_none"
863    )]
864    pub country: Option<Option<String>>,
865    #[serde(
866        default,
867        deserialize_with = "present_nullable",
868        skip_serializing_if = "Option::is_none"
869    )]
870    pub region: Option<Option<String>>,
871    #[serde(
872        default,
873        deserialize_with = "present_nullable",
874        skip_serializing_if = "Option::is_none"
875    )]
876    pub timezone: Option<Option<String>>,
877    #[serde(rename = "type", skip_serializing_if = "Option::is_none")]
878    pub type_: Option<UserLocationType>,
879    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
880    pub rest: Rest,
881}
882#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
883#[serde(rename_all = "snake_case")]
884#[derive(gproxy_protocol_macros::DeclaredFields)]
885pub enum UserLocationType {
886    Approximate,
887}
888#[derive(
889    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
890)]
891#[serde(rename_all = "snake_case")]
892#[derive(gproxy_protocol_macros::DeclaredFields)]
893pub struct PreviewUserLocation {
894    #[serde(rename = "type")]
895    pub type_: UserLocationType,
896    #[serde(
897        default,
898        deserialize_with = "present_nullable",
899        skip_serializing_if = "Option::is_none"
900    )]
901    pub city: Option<Option<String>>,
902    #[serde(
903        default,
904        deserialize_with = "present_nullable",
905        skip_serializing_if = "Option::is_none"
906    )]
907    pub country: Option<Option<String>>,
908    #[serde(
909        default,
910        deserialize_with = "present_nullable",
911        skip_serializing_if = "Option::is_none"
912    )]
913    pub region: Option<Option<String>>,
914    #[serde(
915        default,
916        deserialize_with = "present_nullable",
917        skip_serializing_if = "Option::is_none"
918    )]
919    pub timezone: Option<Option<String>>,
920    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
921    pub rest: Rest,
922}
923#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
924#[serde(tag = "type", rename_all = "snake_case")]
925#[derive(gproxy_protocol_macros::DeclaredFields)]
926pub enum NamespaceToolDefinition {
927    Function(NamespaceFunctionTool),
928    Custom(NamespaceCustomTool),
929}
930#[derive(
931    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
932)]
933#[serde(rename_all = "snake_case")]
934#[derive(gproxy_protocol_macros::DeclaredFields)]
935pub struct NamespaceFunctionTool {
936    #[serde(rename = "async", skip_serializing_if = "Option::is_none")]
937    pub async_: Option<bool>,
938    pub name: String,
939    #[serde(
940        default,
941        deserialize_with = "present_nullable",
942        skip_serializing_if = "Option::is_none"
943    )]
944    pub allowed_callers: Option<Option<Vec<AllowedCaller>>>,
945    #[serde(skip_serializing_if = "Option::is_none")]
946    pub defer_loading: Option<bool>,
947    #[serde(
948        default,
949        deserialize_with = "present_nullable",
950        skip_serializing_if = "Option::is_none"
951    )]
952    pub description: Option<Option<String>>,
953    #[serde(
954        default,
955        deserialize_with = "present_nullable",
956        skip_serializing_if = "Option::is_none"
957    )]
958    pub output_schema: Option<Option<Rest>>,
959    #[serde(
960        default,
961        deserialize_with = "present_nullable",
962        skip_serializing_if = "Option::is_none"
963    )]
964    pub parameters: Option<Option<serde_json::Value>>,
965    #[serde(
966        default,
967        deserialize_with = "present_nullable",
968        skip_serializing_if = "Option::is_none"
969    )]
970    pub strict: Option<Option<bool>>,
971    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
972    pub rest: Rest,
973}
974#[derive(
975    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
976)]
977#[serde(rename_all = "snake_case")]
978#[derive(gproxy_protocol_macros::DeclaredFields)]
979pub struct NamespaceCustomTool {
980    #[serde(rename = "async", skip_serializing_if = "Option::is_none")]
981    pub async_: Option<bool>,
982    pub name: String,
983    #[serde(
984        default,
985        deserialize_with = "present_nullable",
986        skip_serializing_if = "Option::is_none"
987    )]
988    pub allowed_callers: Option<Option<Vec<AllowedCaller>>>,
989    #[serde(skip_serializing_if = "Option::is_none")]
990    pub defer_loading: Option<bool>,
991    #[serde(skip_serializing_if = "Option::is_none")]
992    pub description: Option<String>,
993    #[serde(skip_serializing_if = "Option::is_none")]
994    pub format: Option<CustomToolFormat>,
995    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
996    pub rest: Rest,
997}
998#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
999#[serde(untagged)]
1000#[derive(gproxy_protocol_macros::DeclaredFields)]
1001pub enum ShellEnvironment {
1002    Auto(ShellContainerAuto),
1003    Local(ShellLocalEnvironment),
1004    Reference(ShellContainerReference),
1005}
1006#[derive(
1007    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1008)]
1009#[serde(rename_all = "snake_case")]
1010#[derive(gproxy_protocol_macros::DeclaredFields)]
1011pub struct ShellContainerAuto {
1012    #[serde(rename = "type")]
1013    pub type_: ShellContainerAutoType,
1014    #[serde(skip_serializing_if = "Option::is_none")]
1015    pub file_ids: Option<Vec<String>>,
1016    #[serde(
1017        default,
1018        deserialize_with = "present_nullable",
1019        skip_serializing_if = "Option::is_none"
1020    )]
1021    pub memory_limit: Option<Option<MemoryLimit>>,
1022    #[serde(skip_serializing_if = "Option::is_none")]
1023    pub network_policy: Option<ContainerNetworkPolicy>,
1024    #[serde(skip_serializing_if = "Option::is_none")]
1025    pub skills: Option<Vec<ShellSkill>>,
1026    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1027    pub rest: Rest,
1028}
1029#[derive(
1030    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1031)]
1032#[serde(rename_all = "snake_case")]
1033#[derive(gproxy_protocol_macros::DeclaredFields)]
1034pub struct ShellLocalEnvironment {
1035    #[serde(rename = "type")]
1036    pub type_: ShellLocalType,
1037    #[serde(skip_serializing_if = "Option::is_none")]
1038    pub skills: Option<Vec<LocalSkill>>,
1039    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1040    pub rest: Rest,
1041}
1042#[derive(
1043    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1044)]
1045#[serde(rename_all = "snake_case")]
1046#[derive(gproxy_protocol_macros::DeclaredFields)]
1047pub struct ShellContainerReference {
1048    #[serde(rename = "type")]
1049    pub type_: ShellReferenceType,
1050    pub container_id: String,
1051    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1052    pub rest: Rest,
1053}
1054#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1055#[serde(untagged)]
1056#[derive(gproxy_protocol_macros::DeclaredFields)]
1057pub enum ShellSkill {
1058    Reference(SkillReference),
1059    Inline(InlineSkill),
1060}
1061#[derive(
1062    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1063)]
1064#[serde(rename_all = "snake_case")]
1065#[derive(gproxy_protocol_macros::DeclaredFields)]
1066pub struct SkillReference {
1067    pub skill_id: String,
1068    #[serde(rename = "type")]
1069    pub type_: SkillReferenceType,
1070    #[serde(skip_serializing_if = "Option::is_none")]
1071    pub version: Option<String>,
1072    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1073    pub rest: Rest,
1074}
1075#[derive(
1076    Debug,
1077    Clone,
1078    Copy,
1079    PartialEq,
1080    Eq,
1081    Serialize,
1082    Deserialize,
1083    gproxy_protocol_macros::DeclaredFields,
1084)]
1085pub enum SkillReferenceType {
1086    #[serde(rename = "skill_reference")]
1087    SkillReference,
1088}
1089#[derive(
1090    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1091)]
1092#[serde(rename_all = "snake_case")]
1093#[derive(gproxy_protocol_macros::DeclaredFields)]
1094pub struct InlineSkill {
1095    pub description: String,
1096    pub name: String,
1097    pub source: InlineSkillSource,
1098    #[serde(rename = "type")]
1099    pub type_: InlineSkillType,
1100    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1101    pub rest: Rest,
1102}
1103#[derive(
1104    Debug,
1105    Clone,
1106    Copy,
1107    PartialEq,
1108    Eq,
1109    Serialize,
1110    Deserialize,
1111    gproxy_protocol_macros::DeclaredFields,
1112)]
1113pub enum InlineSkillType {
1114    #[serde(rename = "inline")]
1115    Inline,
1116}
1117#[derive(
1118    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1119)]
1120#[serde(rename_all = "snake_case")]
1121#[derive(gproxy_protocol_macros::DeclaredFields)]
1122pub struct InlineSkillSource {
1123    pub data: String,
1124    pub media_type: ZipMediaType,
1125    #[serde(rename = "type")]
1126    pub type_: Base64SourceType,
1127    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1128    pub rest: Rest,
1129}
1130#[derive(
1131    Debug,
1132    Clone,
1133    Copy,
1134    PartialEq,
1135    Eq,
1136    Serialize,
1137    Deserialize,
1138    gproxy_protocol_macros::DeclaredFields,
1139)]
1140pub enum ZipMediaType {
1141    #[serde(rename = "application/zip")]
1142    Zip,
1143}
1144#[derive(
1145    Debug,
1146    Clone,
1147    Copy,
1148    PartialEq,
1149    Eq,
1150    Serialize,
1151    Deserialize,
1152    gproxy_protocol_macros::DeclaredFields,
1153)]
1154pub enum Base64SourceType {
1155    #[serde(rename = "base64")]
1156    Base64,
1157}
1158#[derive(
1159    Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
1160)]
1161#[serde(rename_all = "snake_case")]
1162#[derive(gproxy_protocol_macros::DeclaredFields)]
1163pub struct LocalSkill {
1164    pub description: String,
1165    pub name: String,
1166    pub path: String,
1167    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
1168    pub rest: Rest,
1169}
1170#[derive(
1171    Debug,
1172    Clone,
1173    Copy,
1174    PartialEq,
1175    Eq,
1176    Serialize,
1177    Deserialize,
1178    gproxy_protocol_macros::DeclaredFields,
1179)]
1180pub enum ShellContainerAutoType {
1181    #[serde(rename = "container_auto")]
1182    ContainerAuto,
1183}
1184#[derive(
1185    Debug,
1186    Clone,
1187    Copy,
1188    PartialEq,
1189    Eq,
1190    Serialize,
1191    Deserialize,
1192    gproxy_protocol_macros::DeclaredFields,
1193)]
1194pub enum ShellLocalType {
1195    #[serde(rename = "local")]
1196    Local,
1197}
1198#[derive(
1199    Debug,
1200    Clone,
1201    Copy,
1202    PartialEq,
1203    Eq,
1204    Serialize,
1205    Deserialize,
1206    gproxy_protocol_macros::DeclaredFields,
1207)]
1208pub enum ShellReferenceType {
1209    #[serde(rename = "container_reference")]
1210    ContainerReference,
1211}
1212#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1213#[serde(rename_all = "snake_case")]
1214#[derive(gproxy_protocol_macros::DeclaredFields)]
1215pub enum AllowedCaller {
1216    Direct,
1217    Programmatic,
1218}
gproxy_protocol/wire/openai/responses/tools.rs

gproxy_protocol/wire/openai/responses/
tools.rs
