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