Skip to main content

gproxy_protocol/protocol/openai/generate_content/response_tools/
runtime.rs

1use std::collections::BTreeMap;
2
3use serde::{Deserialize, Serialize};
4
5use super::super::super::common::*;
6
7#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8#[serde(untagged)]
9pub enum CodeInterpreterContainer {
10    Id(String),
11    Auto(CodeInterpreterAutoContainer),
12}
13
14#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
15pub struct CodeInterpreterAutoContainer {
16    #[serde(rename = "type")]
17    pub type_: CodeInterpreterContainerType,
18    #[serde(skip_serializing_if = "Option::is_none")]
19    pub file_ids: Option<Vec<String>>,
20    #[serde(skip_serializing_if = "Option::is_none")]
21    pub memory_limit: Option<CodeInterpreterMemoryLimit>,
22    #[serde(skip_serializing_if = "Option::is_none")]
23    pub network_policy: Option<CodeInterpreterNetworkPolicy>,
24    #[serde(default, flatten, skip_serializing_if = "BTreeMap::is_empty")]
25    pub extra: Extra,
26}
27
28#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
29#[serde(tag = "type")]
30pub enum CodeInterpreterNetworkPolicy {
31    #[serde(rename = "disabled")]
32    Disabled {
33        #[serde(default, flatten, skip_serializing_if = "BTreeMap::is_empty")]
34        extra: Extra,
35    },
36    #[serde(rename = "allowlist")]
37    Allowlist {
38        allowed_domains: Vec<String>,
39        #[serde(skip_serializing_if = "Option::is_none")]
40        domain_secrets: Option<Vec<CodeInterpreterDomainSecret>>,
41        #[serde(default, flatten, skip_serializing_if = "BTreeMap::is_empty")]
42        extra: Extra,
43    },
44}
45
46#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
47pub struct CodeInterpreterDomainSecret {
48    pub domain: String,
49    pub name: String,
50    pub value: String,
51    #[serde(default, flatten, skip_serializing_if = "BTreeMap::is_empty")]
52    pub extra: Extra,
53}
54
55#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
56pub struct ImageMask {
57    #[serde(skip_serializing_if = "Option::is_none")]
58    pub file_id: Option<String>,
59    #[serde(skip_serializing_if = "Option::is_none")]
60    pub image_url: Option<String>,
61    #[serde(default, flatten, skip_serializing_if = "BTreeMap::is_empty")]
62    pub extra: Extra,
63}
64
65#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
66#[serde(tag = "type")]
67pub enum ResponseShellEnvironment {
68    #[serde(rename = "container_auto")]
69    ContainerAuto {
70        #[serde(skip_serializing_if = "Option::is_none")]
71        file_ids: Option<Vec<String>>,
72        #[serde(skip_serializing_if = "Option::is_none")]
73        memory_limit: Option<CodeInterpreterMemoryLimit>,
74        #[serde(skip_serializing_if = "Option::is_none")]
75        network_policy: Option<CodeInterpreterNetworkPolicy>,
76        #[serde(skip_serializing_if = "Option::is_none")]
77        skills: Option<Vec<ResponseShellContainerSkill>>,
78    },
79    #[serde(rename = "local")]
80    Local {
81        #[serde(skip_serializing_if = "Option::is_none")]
82        skills: Option<Vec<ResponseShellLocalSkill>>,
83    },
84    #[serde(rename = "container_reference")]
85    ContainerReference { container_id: String },
86}
87
88#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
89#[serde(untagged)]
90pub enum ResponseShellContainerSkill {
91    Reference(ResponseShellSkillReference),
92    Inline(ResponseShellInlineSkill),
93}
94
95#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
96pub struct ResponseShellSkillReference {
97    pub skill_id: String,
98    #[serde(rename = "type")]
99    pub type_: ResponseShellSkillReferenceType,
100    #[serde(skip_serializing_if = "Option::is_none")]
101    pub version: Option<String>,
102    #[serde(default, flatten, skip_serializing_if = "BTreeMap::is_empty")]
103    pub extra: Extra,
104}
105
106#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
107pub enum ResponseShellSkillReferenceType {
108    #[serde(rename = "skill_reference")]
109    SkillReference,
110}
111
112#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
113pub struct ResponseShellInlineSkill {
114    pub description: String,
115    pub name: String,
116    pub source: ResponseShellInlineSkillSource,
117    #[serde(rename = "type")]
118    pub type_: ResponseShellInlineSkillType,
119    #[serde(default, flatten, skip_serializing_if = "BTreeMap::is_empty")]
120    pub extra: Extra,
121}
122
123#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
124pub enum ResponseShellInlineSkillType {
125    #[serde(rename = "inline")]
126    Inline,
127}
128
129#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
130pub struct ResponseShellInlineSkillSource {
131    pub data: String,
132    pub media_type: ResponseShellInlineSkillMediaType,
133    #[serde(rename = "type")]
134    pub type_: ResponseShellInlineSkillSourceType,
135    #[serde(default, flatten, skip_serializing_if = "BTreeMap::is_empty")]
136    pub extra: Extra,
137}
138
139#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
140pub enum ResponseShellInlineSkillMediaType {
141    #[serde(rename = "application/zip")]
142    ApplicationZip,
143}
144
145#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
146pub enum ResponseShellInlineSkillSourceType {
147    #[serde(rename = "base64")]
148    Base64,
149}
150
151#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
152pub struct ResponseShellLocalSkill {
153    pub description: String,
154    pub name: String,
155    pub path: String,
156    #[serde(default, flatten, skip_serializing_if = "BTreeMap::is_empty")]
157    pub extra: Extra,
158}
159
160#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
161pub enum SearchContentType {
162    #[serde(rename = "text")]
163    Text,
164    #[serde(rename = "image")]
165    Image,
166}
167
168#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
169pub struct WebSearchPreviewUserLocation {
170    #[serde(rename = "type")]
171    pub type_: ApproximateLocationType,
172    #[serde(skip_serializing_if = "Option::is_none")]
173    pub city: Option<String>,
174    #[serde(skip_serializing_if = "Option::is_none")]
175    pub country: Option<String>,
176    #[serde(skip_serializing_if = "Option::is_none")]
177    pub region: Option<String>,
178    #[serde(skip_serializing_if = "Option::is_none")]
179    pub timezone: Option<String>,
180    #[serde(default, flatten, skip_serializing_if = "BTreeMap::is_empty")]
181    pub extra: Extra,
182}