1use super::codex::Reasoning;
3use crate::Rest;
4use serde::{Deserialize, Serialize};
5#[derive(Debug, Clone, Serialize, PartialEq, Deserialize, gproxy_protocol_macros::WireBuilder)]
6#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
7#[derive(gproxy_protocol_macros::DeclaredFields)]
8#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
9pub struct WebSearchRequestBody {
10 pub id: String,
11 pub model: String,
12 #[serde(skip_serializing_if = "Option::is_none")]
13 pub reasoning: Option<Reasoning>,
14 #[serde(skip_serializing_if = "Option::is_none")]
15 pub input: Option<SearchInput>,
16 #[serde(skip_serializing_if = "Option::is_none")]
17 pub commands: Option<SearchCommands>,
18 #[serde(skip_serializing_if = "Option::is_none")]
19 pub settings: Option<SearchSettings>,
20 #[serde(skip_serializing_if = "Option::is_none")]
21 pub max_output_tokens: Option<u64>,
22 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
23 pub rest: Rest,
24}
25
26#[derive(Debug, Clone, Serialize, PartialEq, Deserialize)]
27#[serde(untagged)]
28#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
29#[derive(gproxy_protocol_macros::DeclaredFields)]
30#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
31pub enum SearchInput {
32 Text(String),
33 Items(Vec<super::codex::ClientResponseItem>),
34}
35
36#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, gproxy_protocol_macros::WireBuilder)]
37#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
38#[derive(gproxy_protocol_macros::DeclaredFields)]
39#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
40pub struct SearchCommands {
41 #[serde(skip_serializing_if = "Option::is_none")]
42 pub search_query: Option<Vec<SearchQuery>>,
43 #[serde(skip_serializing_if = "Option::is_none")]
44 pub literature_search_query: Option<Vec<SearchQuery>>,
45 #[serde(skip_serializing_if = "Option::is_none")]
46 pub image_query: Option<Vec<SearchQuery>>,
47 #[serde(skip_serializing_if = "Option::is_none")]
48 pub open: Option<Vec<OpenOperation>>,
49 #[serde(skip_serializing_if = "Option::is_none")]
50 pub click: Option<Vec<ClickOperation>>,
51 #[serde(skip_serializing_if = "Option::is_none")]
52 pub find: Option<Vec<FindOperation>>,
53 #[serde(skip_serializing_if = "Option::is_none")]
54 pub screenshot: Option<Vec<ScreenshotOperation>>,
55 #[serde(skip_serializing_if = "Option::is_none")]
56 pub finance: Option<Vec<FinanceOperation>>,
57 #[serde(skip_serializing_if = "Option::is_none")]
58 pub weather: Option<Vec<WeatherOperation>>,
59 #[serde(skip_serializing_if = "Option::is_none")]
60 pub sports: Option<Vec<SportsOperation>>,
61 #[serde(skip_serializing_if = "Option::is_none")]
62 pub time: Option<Vec<TimeOperation>>,
63 #[serde(skip_serializing_if = "Option::is_none")]
64 pub response_length: Option<SearchResponseLength>,
65 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
66 pub rest: Rest,
67}
68
69#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, gproxy_protocol_macros::WireBuilder)]
70#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
71#[derive(gproxy_protocol_macros::DeclaredFields)]
72#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
73pub struct SearchQuery {
74 pub q: String,
75 #[serde(skip_serializing_if = "Option::is_none")]
76 pub recency: Option<u64>,
77 #[serde(skip_serializing_if = "Option::is_none")]
78 pub domains: Option<Vec<String>>,
79 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
80 pub rest: Rest,
81}
82
83#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, gproxy_protocol_macros::WireBuilder)]
84#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
85#[derive(gproxy_protocol_macros::DeclaredFields)]
86#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
87pub struct OpenOperation {
88 pub ref_id: String,
89 #[serde(skip_serializing_if = "Option::is_none")]
90 pub lineno: Option<u64>,
91 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
92 pub rest: Rest,
93}
94
95#[derive(
96 Debug, Clone, Serialize, Deserialize, PartialEq, Eq, gproxy_protocol_macros::WireBuilder,
97)]
98#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
99#[derive(gproxy_protocol_macros::DeclaredFields)]
100#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
101pub struct ClickOperation {
102 pub ref_id: String,
103 pub id: u64,
104 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
105 pub rest: Rest,
106}
107
108#[derive(
109 Debug, Clone, Serialize, Deserialize, PartialEq, Eq, gproxy_protocol_macros::WireBuilder,
110)]
111#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
112#[derive(gproxy_protocol_macros::DeclaredFields)]
113#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
114pub struct FindOperation {
115 pub ref_id: String,
116 pub pattern: String,
117 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
118 pub rest: Rest,
119}
120
121#[derive(
122 Debug, Clone, Serialize, Deserialize, PartialEq, Eq, gproxy_protocol_macros::WireBuilder,
123)]
124#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
125#[derive(gproxy_protocol_macros::DeclaredFields)]
126#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
127pub struct ScreenshotOperation {
128 pub ref_id: String,
129 pub pageno: u64,
130 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
131 pub rest: Rest,
132}
133
134#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, gproxy_protocol_macros::WireBuilder)]
135#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
136#[derive(gproxy_protocol_macros::DeclaredFields)]
137#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
138pub struct FinanceOperation {
139 pub ticker: String,
140 pub r#type: FinanceAssetType,
141 #[serde(skip_serializing_if = "Option::is_none")]
142 pub market: Option<String>,
143 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
144 pub rest: Rest,
145}
146
147#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
148#[serde(rename_all = "lowercase")]
149#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
150#[derive(gproxy_protocol_macros::DeclaredFields)]
151#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
152pub enum FinanceAssetType {
153 Equity,
154 Fund,
155 Crypto,
156 Index,
157}
158
159#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, gproxy_protocol_macros::WireBuilder)]
160#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
161#[derive(gproxy_protocol_macros::DeclaredFields)]
162#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
163pub struct WeatherOperation {
164 pub location: String,
165 #[serde(skip_serializing_if = "Option::is_none")]
166 pub start: Option<String>,
167 #[serde(skip_serializing_if = "Option::is_none")]
168 pub duration: Option<u64>,
169 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
170 pub rest: Rest,
171}
172
173#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, gproxy_protocol_macros::WireBuilder)]
174#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
175#[derive(gproxy_protocol_macros::DeclaredFields)]
176#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
177pub struct SportsOperation {
178 #[serde(skip_serializing_if = "Option::is_none")]
179 pub tool: Option<SportsToolName>,
180 pub r#fn: SportsFunction,
181 pub league: SportsLeague,
182 #[serde(skip_serializing_if = "Option::is_none")]
183 pub team: Option<String>,
184 #[serde(skip_serializing_if = "Option::is_none")]
185 pub opponent: Option<String>,
186 #[serde(skip_serializing_if = "Option::is_none")]
187 pub date_from: Option<String>,
188 #[serde(skip_serializing_if = "Option::is_none")]
189 pub date_to: Option<String>,
190 #[serde(skip_serializing_if = "Option::is_none")]
191 pub num_games: Option<u64>,
192 #[serde(skip_serializing_if = "Option::is_none")]
193 pub locale: Option<String>,
194 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
195 pub rest: Rest,
196}
197
198#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
199#[serde(rename_all = "lowercase")]
200#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
201#[derive(gproxy_protocol_macros::DeclaredFields)]
202#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
203pub enum SportsToolName {
204 Sports,
205}
206
207#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
208#[serde(rename_all = "lowercase")]
209#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
210#[derive(gproxy_protocol_macros::DeclaredFields)]
211#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
212pub enum SportsFunction {
213 Schedule,
214 Standings,
215}
216
217#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
218#[serde(rename_all = "lowercase")]
219#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
220#[derive(gproxy_protocol_macros::DeclaredFields)]
221#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
222pub enum SportsLeague {
223 Nba,
224 Wnba,
225 Nfl,
226 Nhl,
227 Mlb,
228 Epl,
229 Ncaamb,
230 Ncaawb,
231 Ipl,
232}
233
234#[derive(
235 Debug, Clone, Serialize, Deserialize, PartialEq, Eq, gproxy_protocol_macros::WireBuilder,
236)]
237#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
238#[derive(gproxy_protocol_macros::DeclaredFields)]
239#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
240pub struct TimeOperation {
241 pub utc_offset: String,
242 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
243 pub rest: Rest,
244}
245
246#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
247#[serde(rename_all = "lowercase")]
248#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
249#[derive(gproxy_protocol_macros::DeclaredFields)]
250#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
251pub enum SearchResponseLength {
252 Short,
253 Medium,
254 Long,
255}
256
257#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
258#[serde(rename_all = "snake_case")]
259#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
260#[derive(gproxy_protocol_macros::DeclaredFields)]
261#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
262pub enum ExternalWebAccessMode {
263 Cached,
264 Indexed,
265 Live,
266}
267
268#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
269#[serde(untagged)]
270#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
271#[derive(gproxy_protocol_macros::DeclaredFields)]
272#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
273pub enum ExternalWebAccess {
274 Boolean(bool),
275 Mode(ExternalWebAccessMode),
276}
277
278#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, gproxy_protocol_macros::WireBuilder)]
279#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
280#[derive(gproxy_protocol_macros::DeclaredFields)]
281#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
282pub struct SearchSettings {
283 #[serde(skip_serializing_if = "Option::is_none")]
284 pub user_location: Option<ApproximateLocation>,
285 #[serde(skip_serializing_if = "Option::is_none")]
286 pub search_context_size: Option<SearchContextSize>,
287 #[serde(skip_serializing_if = "Option::is_none")]
288 pub filters: Option<SearchFilters>,
289 #[serde(skip_serializing_if = "Option::is_none")]
290 pub image_settings: Option<SearchImageSettings>,
291 #[serde(skip_serializing_if = "Option::is_none")]
292 pub allowed_callers: Option<Vec<AllowedCaller>>,
293 #[serde(skip_serializing_if = "Option::is_none")]
294 pub external_web_access: Option<ExternalWebAccess>,
295 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
296 pub rest: Rest,
297}
298
299#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, gproxy_protocol_macros::WireBuilder)]
300#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
301#[derive(gproxy_protocol_macros::DeclaredFields)]
302#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
303pub struct ApproximateLocation {
304 pub r#type: LocationType,
305 #[serde(skip_serializing_if = "Option::is_none")]
306 pub country: Option<String>,
307 #[serde(skip_serializing_if = "Option::is_none")]
308 pub region: Option<String>,
309 #[serde(skip_serializing_if = "Option::is_none")]
310 pub city: Option<String>,
311 #[serde(skip_serializing_if = "Option::is_none")]
312 pub timezone: Option<String>,
313 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
314 pub rest: Rest,
315}
316
317#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
318#[serde(rename_all = "lowercase")]
319#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
320#[derive(gproxy_protocol_macros::DeclaredFields)]
321#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
322pub enum LocationType {
323 Approximate,
324}
325
326#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
327#[serde(rename_all = "lowercase")]
328#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
329#[derive(gproxy_protocol_macros::DeclaredFields)]
330#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
331pub enum SearchContextSize {
332 Low,
333 Medium,
334 High,
335}
336
337#[derive(
338 Debug, Clone, Serialize, Deserialize, PartialEq, Eq, gproxy_protocol_macros::WireBuilder,
339)]
340#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
341#[derive(gproxy_protocol_macros::DeclaredFields)]
342#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
343pub struct SearchFilters {
344 #[serde(skip_serializing_if = "Option::is_none")]
345 pub allowed_domains: Option<Vec<String>>,
346 #[serde(skip_serializing_if = "Option::is_none")]
347 pub blocked_domains: Option<Vec<String>>,
348 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
349 pub rest: Rest,
350}
351
352#[derive(
353 Debug, Clone, Serialize, Deserialize, PartialEq, Eq, gproxy_protocol_macros::WireBuilder,
354)]
355#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
356#[derive(gproxy_protocol_macros::DeclaredFields)]
357#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
358pub struct SearchImageSettings {
359 #[serde(skip_serializing_if = "Option::is_none")]
360 pub max_results: Option<u64>,
361 #[serde(skip_serializing_if = "Option::is_none")]
362 pub caption: Option<bool>,
363 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
364 pub rest: Rest,
365}
366
367#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
368#[serde(rename_all = "snake_case")]
369#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
370#[derive(gproxy_protocol_macros::DeclaredFields)]
371#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
372pub enum AllowedCaller {
373 Direct,
374 Shell,
375 CodeInterpreter,
376}
377
378#[derive(
379 Debug, Clone, Deserialize, PartialEq, Eq, Serialize, gproxy_protocol_macros::WireBuilder,
380)]
381#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
382#[derive(gproxy_protocol_macros::DeclaredFields)]
383#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
384pub struct WebSearchResponseBody {
385 #[serde(
386 default,
387 deserialize_with = "super::responses::input::present_nullable",
388 skip_serializing_if = "Option::is_none"
389 )]
390 pub encrypted_output: Option<Option<String>>,
391 pub output: String,
392 #[serde(
393 default,
394 deserialize_with = "super::responses::input::present_nullable",
395 skip_serializing_if = "Option::is_none"
396 )]
397 pub results: Option<Option<Vec<serde_json::Value>>>,
398 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
399 pub rest: Rest,
400}
401
402pub type WebSearchRequest = crate::WireRequest<WebSearchRequestBody>;
403pub type WebSearchResponse = crate::WireResponse<WebSearchResponseBody>;