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

gproxy_protocol/wire/openai/responses/
tools.rs
