1use super::*;
4
5#[derive(Clone, Debug, PartialEq)]
6pub enum AiAgent {
7 AiAgentAsk(AiAgentAsk),
8 AiAgentTextGen(AiAgentTextGen),
9 AiAgentExtract(AiAgentExtract),
10 AiAgentExtractStructured(AiAgentExtractStructured),
11 Unknown(serde_json::Value),
13}
14
15impl Default for AiAgent {
16 fn default() -> Self {
17 Self::Unknown(Default::default())
18 }
19}
20
21impl serde::Serialize for AiAgent {
22 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
23 match self {
24 Self::AiAgentAsk(inner) => inner.serialize(serializer),
25 Self::AiAgentTextGen(inner) => inner.serialize(serializer),
26 Self::AiAgentExtract(inner) => inner.serialize(serializer),
27 Self::AiAgentExtractStructured(inner) => inner.serialize(serializer),
28 Self::Unknown(inner) => inner.serialize(serializer),
29 }
30 }
31}
32
33impl<'de> serde::Deserialize<'de> for AiAgent {
34 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
35 let value = serde_json::Value::deserialize(deserializer)?;
36 let tag = value
37 .get("type")
38 .and_then(serde_json::Value::as_str)
39 .map(str::to_owned);
40 match tag.as_deref() {
41 Some("ai_agent_ask") => Ok(Self::AiAgentAsk(
42 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
43 )),
44 Some("ai_agent_text_gen") => Ok(Self::AiAgentTextGen(
45 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
46 )),
47 Some("ai_agent_extract") => Ok(Self::AiAgentExtract(
48 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
49 )),
50 Some("ai_agent_extract_structured") => Ok(Self::AiAgentExtractStructured(
51 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
52 )),
53 _ => Ok(Self::Unknown(value)),
54 }
55 }
56}
57
58#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
59pub struct AiAgentAsk {
60 pub r#type: AiAgentAskType,
61 #[serde(default, skip_serializing_if = "Option::is_none")]
62 pub long_text: Option<AiAgentLongTextTool>,
63 #[serde(default, skip_serializing_if = "Option::is_none")]
64 pub basic_text: Option<AiAgentBasicTextTool>,
65 #[serde(default, skip_serializing_if = "Option::is_none")]
66 pub spreadsheet: Option<AiAgentSpreadsheetTool>,
67 #[serde(default, skip_serializing_if = "Option::is_none")]
68 pub long_text_multi: Option<AiAgentLongTextTool>,
69 #[serde(default, skip_serializing_if = "Option::is_none")]
70 pub basic_text_multi: Option<AiAgentBasicTextTool>,
71 #[serde(default, skip_serializing_if = "Option::is_none")]
72 pub basic_image: Option<AiAgentBasicTextTool>,
73 #[serde(default, skip_serializing_if = "Option::is_none")]
74 pub basic_image_multi: Option<AiAgentBasicTextTool>,
75}
76
77#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
78pub struct AiAgentBasicGenTool {
79 #[serde(default, skip_serializing_if = "Option::is_none")]
80 pub model: Option<String>,
81 #[serde(default, skip_serializing_if = "Option::is_none")]
82 pub num_tokens_for_completion: Option<i64>,
83 #[serde(default, skip_serializing_if = "Option::is_none")]
84 pub llm_endpoint_params: Option<AiLlmEndpointParams>,
85 #[serde(default, skip_serializing_if = "Option::is_none")]
86 pub system_message: Option<String>,
87 #[serde(default, skip_serializing_if = "Option::is_none")]
88 pub prompt_template: Option<String>,
89 #[serde(default, skip_serializing_if = "Option::is_none")]
90 pub embeddings: Option<AiAgentBasicGenToolEmbeddings>,
91 #[serde(default, skip_serializing_if = "Option::is_none")]
92 pub content_template: Option<String>,
93}
94
95#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
96pub struct AiAgentBasicTextTool {
97 #[serde(default, skip_serializing_if = "Option::is_none")]
98 pub model: Option<String>,
99 #[serde(default, skip_serializing_if = "Option::is_none")]
100 pub num_tokens_for_completion: Option<i64>,
101 #[serde(default, skip_serializing_if = "Option::is_none")]
102 pub llm_endpoint_params: Option<AiLlmEndpointParams>,
103 #[serde(default, skip_serializing_if = "Option::is_none")]
104 pub system_message: Option<String>,
105 #[serde(default, skip_serializing_if = "Option::is_none")]
106 pub prompt_template: Option<String>,
107}
108
109#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
110pub struct AiAgentExtract {
111 pub r#type: AiAgentExtractType,
112 #[serde(default, skip_serializing_if = "Option::is_none")]
113 pub long_text: Option<AiAgentLongTextTool>,
114 #[serde(default, skip_serializing_if = "Option::is_none")]
115 pub basic_text: Option<AiAgentBasicTextTool>,
116 #[serde(default, skip_serializing_if = "Option::is_none")]
117 pub basic_image: Option<AiAgentBasicTextTool>,
118}
119
120#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
121pub struct AiAgentExtractStructured {
122 pub r#type: AiAgentExtractStructuredType,
123 #[serde(default, skip_serializing_if = "Option::is_none")]
124 pub long_text: Option<AiAgentLongTextTool>,
125 #[serde(default, skip_serializing_if = "Option::is_none")]
126 pub basic_text: Option<AiAgentBasicTextTool>,
127 #[serde(default, skip_serializing_if = "Option::is_none")]
128 pub basic_image: Option<AiAgentBasicTextTool>,
129}
130
131#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
132pub struct AiAgentInfo {
133 #[serde(default, skip_serializing_if = "Option::is_none")]
134 pub models: Option<Vec<AiAgentInfoModels>>,
135 #[serde(default, skip_serializing_if = "Option::is_none")]
136 pub processor: Option<String>,
137}
138
139#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
140pub struct AiAgentLongTextTool {
141 #[serde(default, skip_serializing_if = "Option::is_none")]
142 pub model: Option<String>,
143 #[serde(default, skip_serializing_if = "Option::is_none")]
144 pub num_tokens_for_completion: Option<i64>,
145 #[serde(default, skip_serializing_if = "Option::is_none")]
146 pub llm_endpoint_params: Option<AiLlmEndpointParams>,
147 #[serde(default, skip_serializing_if = "Option::is_none")]
148 pub system_message: Option<String>,
149 #[serde(default, skip_serializing_if = "Option::is_none")]
150 pub prompt_template: Option<String>,
151 #[serde(default, skip_serializing_if = "Option::is_none")]
152 pub embeddings: Option<AiAgentBasicGenToolEmbeddings>,
153}
154
155#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
156pub struct AiAgentReference {
157 pub r#type: AiAgentReferenceType,
158 pub id: String,
159}
160
161#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
162pub struct AiAgentTextGen {
163 pub r#type: AiAgentTextGenType,
164 #[serde(default, skip_serializing_if = "Option::is_none")]
165 pub basic_gen: Option<AiAgentBasicGenTool>,
166}
167
168#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
169pub struct AiAsk {
170 pub mode: AiAskMode,
171 pub prompt: String,
172 pub items: Vec<AiItemAsk>,
173 #[serde(default, skip_serializing_if = "Option::is_none")]
174 pub dialogue_history: Option<Vec<AiDialogueHistory>>,
175 #[serde(default, skip_serializing_if = "Option::is_none")]
176 pub include_citations: Option<bool>,
177 #[serde(default, skip_serializing_if = "Option::is_none")]
178 pub ai_agent: Option<AiAskAgent>,
179}
180
181#[derive(Clone, Debug, PartialEq)]
182pub enum AiAskAgent {
183 AiAgentId(AiAgentReference),
184 AiAgentAsk(AiAgentAsk),
185 Unknown(serde_json::Value),
187}
188
189impl Default for AiAskAgent {
190 fn default() -> Self {
191 Self::Unknown(Default::default())
192 }
193}
194
195impl serde::Serialize for AiAskAgent {
196 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
197 match self {
198 Self::AiAgentId(inner) => inner.serialize(serializer),
199 Self::AiAgentAsk(inner) => inner.serialize(serializer),
200 Self::Unknown(inner) => inner.serialize(serializer),
201 }
202 }
203}
204
205impl<'de> serde::Deserialize<'de> for AiAskAgent {
206 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
207 let value = serde_json::Value::deserialize(deserializer)?;
208 let tag = value
209 .get("type")
210 .and_then(serde_json::Value::as_str)
211 .map(str::to_owned);
212 match tag.as_deref() {
213 Some("ai_agent_id") => Ok(Self::AiAgentId(
214 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
215 )),
216 Some("ai_agent_ask") => Ok(Self::AiAgentAsk(
217 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
218 )),
219 _ => Ok(Self::Unknown(value)),
220 }
221 }
222}
223
224#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
225pub struct AiCitation {
226 #[serde(default, skip_serializing_if = "Option::is_none")]
227 pub content: Option<String>,
228 #[serde(default, skip_serializing_if = "Option::is_none")]
229 pub id: Option<String>,
230 #[serde(default, skip_serializing_if = "Option::is_none")]
231 pub r#type: Option<AiCitationType>,
232 #[serde(default, skip_serializing_if = "Option::is_none")]
233 pub name: Option<String>,
234}
235
236#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
237pub struct AiDialogueHistory {
238 #[serde(default, skip_serializing_if = "Option::is_none")]
239 pub prompt: Option<String>,
240 #[serde(default, skip_serializing_if = "Option::is_none")]
241 pub answer: Option<String>,
242 #[serde(default, skip_serializing_if = "Option::is_none")]
243 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
244}
245
246#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
247pub struct AiExtract {
248 pub prompt: String,
249 pub items: Vec<AiItemBase>,
250 #[serde(default, skip_serializing_if = "Option::is_none")]
251 pub ai_agent: Option<AiExtractAgent>,
252}
253
254#[derive(Clone, Debug, PartialEq)]
255pub enum AiExtractAgent {
256 AiAgentId(AiAgentReference),
257 AiAgentExtract(AiAgentExtract),
258 Unknown(serde_json::Value),
260}
261
262impl Default for AiExtractAgent {
263 fn default() -> Self {
264 Self::Unknown(Default::default())
265 }
266}
267
268impl serde::Serialize for AiExtractAgent {
269 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
270 match self {
271 Self::AiAgentId(inner) => inner.serialize(serializer),
272 Self::AiAgentExtract(inner) => inner.serialize(serializer),
273 Self::Unknown(inner) => inner.serialize(serializer),
274 }
275 }
276}
277
278impl<'de> serde::Deserialize<'de> for AiExtractAgent {
279 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
280 let value = serde_json::Value::deserialize(deserializer)?;
281 let tag = value
282 .get("type")
283 .and_then(serde_json::Value::as_str)
284 .map(str::to_owned);
285 match tag.as_deref() {
286 Some("ai_agent_id") => Ok(Self::AiAgentId(
287 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
288 )),
289 Some("ai_agent_extract") => Ok(Self::AiAgentExtract(
290 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
291 )),
292 _ => Ok(Self::Unknown(value)),
293 }
294 }
295}
296
297#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
298pub struct AiExtractFieldOption {
299 pub key: String,
300}
301
302#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
303pub struct AiExtractResponse {
304 #[serde(flatten)]
305 pub extra: std::collections::HashMap<String, serde_json::Value>,
306}
307
308#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
309pub struct AiExtractStructured {
310 pub items: Vec<AiItemBase>,
311 #[serde(default, skip_serializing_if = "Option::is_none")]
312 pub metadata_template: Option<AiExtractStructuredMetadataTemplate>,
313 #[serde(default, skip_serializing_if = "Option::is_none")]
314 pub fields: Option<Vec<AiExtractStructuredFields>>,
315 #[serde(default, skip_serializing_if = "Option::is_none")]
316 pub ai_agent: Option<AiExtractStructuredAgent>,
317 #[serde(default, skip_serializing_if = "Option::is_none")]
318 pub include_confidence_score: Option<bool>,
319 #[serde(default, skip_serializing_if = "Option::is_none")]
320 pub include_reference: Option<bool>,
321 #[serde(default, skip_serializing_if = "Option::is_none")]
322 pub taxonomy_sources: Option<Vec<AiTaxonomySource>>,
323}
324
325#[derive(Clone, Debug, PartialEq)]
326pub enum AiExtractStructuredAgent {
327 AiAgentId(AiAgentReference),
328 AiAgentExtractStructured(AiAgentExtractStructured),
329 Unknown(serde_json::Value),
331}
332
333impl Default for AiExtractStructuredAgent {
334 fn default() -> Self {
335 Self::Unknown(Default::default())
336 }
337}
338
339impl serde::Serialize for AiExtractStructuredAgent {
340 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
341 match self {
342 Self::AiAgentId(inner) => inner.serialize(serializer),
343 Self::AiAgentExtractStructured(inner) => inner.serialize(serializer),
344 Self::Unknown(inner) => inner.serialize(serializer),
345 }
346 }
347}
348
349impl<'de> serde::Deserialize<'de> for AiExtractStructuredAgent {
350 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
351 let value = serde_json::Value::deserialize(deserializer)?;
352 let tag = value
353 .get("type")
354 .and_then(serde_json::Value::as_str)
355 .map(str::to_owned);
356 match tag.as_deref() {
357 Some("ai_agent_id") => Ok(Self::AiAgentId(
358 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
359 )),
360 Some("ai_agent_extract_structured") => Ok(Self::AiAgentExtractStructured(
361 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
362 )),
363 _ => Ok(Self::Unknown(value)),
364 }
365 }
366}
367
368#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
369pub struct AiExtractStructuredResponse {
370 pub answer: AiExtractResponse,
371 pub created_at: chrono::DateTime<chrono::Utc>,
372 #[serde(default, skip_serializing_if = "Option::is_none")]
373 pub completion_reason: Option<String>,
374 #[serde(default, skip_serializing_if = "Option::is_none")]
375 pub confidence_score: Option<std::collections::HashMap<String, serde_json::Value>>,
376 #[serde(default, skip_serializing_if = "Option::is_none")]
377 pub reference: Option<std::collections::HashMap<String, serde_json::Value>>,
378 #[serde(default, skip_serializing_if = "Option::is_none")]
379 pub ai_agent_info: Option<AiAgentInfo>,
380}
381
382#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
383pub struct AiExtractSubField {
384 pub key: String,
385 #[serde(default, skip_serializing_if = "Option::is_none")]
386 pub description: Option<String>,
387 #[serde(
388 rename = "displayName",
389 default,
390 skip_serializing_if = "Option::is_none"
391 )]
392 pub display_name: Option<String>,
393 #[serde(default, skip_serializing_if = "Option::is_none")]
394 pub prompt: Option<String>,
395 #[serde(default, skip_serializing_if = "Option::is_none")]
396 pub r#type: Option<String>,
397 #[serde(default, skip_serializing_if = "Option::is_none")]
398 pub options: Option<Vec<AiExtractFieldOption>>,
399}
400
401#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
402pub struct AiItemBase {
403 pub id: String,
404 pub r#type: AiCitationType,
405 #[serde(default, skip_serializing_if = "Option::is_none")]
406 pub content: Option<String>,
407}
408
409#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
410pub struct AiItemAsk {
411 pub id: String,
412 pub r#type: AiItemAskType,
413 #[serde(default, skip_serializing_if = "Option::is_none")]
414 pub content: Option<String>,
415}
416
417#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
418pub struct AiOptionsRules {
419 #[serde(default, skip_serializing_if = "Option::is_none")]
420 pub multi_select: Option<bool>,
421 #[serde(default, skip_serializing_if = "Option::is_none")]
422 pub selectable_levels: Option<Vec<i64>>,
423}
424
425#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
426pub struct AiResponse {
427 pub answer: String,
428 pub created_at: chrono::DateTime<chrono::Utc>,
429 #[serde(default, skip_serializing_if = "Option::is_none")]
430 pub completion_reason: Option<String>,
431 #[serde(default, skip_serializing_if = "Option::is_none")]
432 pub ai_agent_info: Option<AiAgentInfo>,
433}
434
435#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
436pub struct AiResponseFull {
437 pub answer: String,
438 pub created_at: chrono::DateTime<chrono::Utc>,
439 #[serde(default, skip_serializing_if = "Option::is_none")]
440 pub completion_reason: Option<String>,
441 #[serde(default, skip_serializing_if = "Option::is_none")]
442 pub ai_agent_info: Option<AiAgentInfo>,
443 #[serde(default, skip_serializing_if = "Option::is_none")]
444 pub citations: Option<Vec<AiCitation>>,
445}
446
447#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
448pub struct AiTaxonomyFileReference {
449 #[serde(default, skip_serializing_if = "Option::is_none")]
450 pub r#type: Option<AiCitationType>,
451 #[serde(default, skip_serializing_if = "Option::is_none")]
452 pub taxonomy_key: Option<String>,
453 #[serde(default, skip_serializing_if = "Option::is_none")]
454 pub id: Option<String>,
455}
456
457#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
458pub struct AiTaxonomyReference {
459 #[serde(default, skip_serializing_if = "Option::is_none")]
460 pub r#type: Option<AiTaxonomyReferenceType>,
461 #[serde(default, skip_serializing_if = "Option::is_none")]
462 pub taxonomy_key: Option<String>,
463 #[serde(default, skip_serializing_if = "Option::is_none")]
464 pub namespace: Option<String>,
465}
466
467#[derive(Clone, Debug, PartialEq)]
468pub enum AiTaxonomySource {
469 Taxonomy(AiTaxonomyReference),
470 File(AiTaxonomyFileReference),
471 Unknown(serde_json::Value),
473}
474
475impl Default for AiTaxonomySource {
476 fn default() -> Self {
477 Self::Unknown(Default::default())
478 }
479}
480
481impl serde::Serialize for AiTaxonomySource {
482 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
483 match self {
484 Self::Taxonomy(inner) => inner.serialize(serializer),
485 Self::File(inner) => inner.serialize(serializer),
486 Self::Unknown(inner) => inner.serialize(serializer),
487 }
488 }
489}
490
491impl<'de> serde::Deserialize<'de> for AiTaxonomySource {
492 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
493 let value = serde_json::Value::deserialize(deserializer)?;
494 let tag = value
495 .get("type")
496 .and_then(serde_json::Value::as_str)
497 .map(str::to_owned);
498 match tag.as_deref() {
499 Some("taxonomy") => Ok(Self::Taxonomy(
500 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
501 )),
502 Some("file") => Ok(Self::File(
503 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
504 )),
505 _ => Ok(Self::Unknown(value)),
506 }
507 }
508}
509
510#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
511pub struct AiTextGen {
512 pub prompt: String,
513 pub items: Vec<AiTextGenItems>,
514 #[serde(default, skip_serializing_if = "Option::is_none")]
515 pub dialogue_history: Option<Vec<AiDialogueHistory>>,
516 #[serde(default, skip_serializing_if = "Option::is_none")]
517 pub ai_agent: Option<AiTextGenAgent>,
518}
519
520#[derive(Clone, Debug, PartialEq)]
521pub enum AiTextGenAgent {
522 AiAgentId(AiAgentReference),
523 AiAgentTextGen(AiAgentTextGen),
524 Unknown(serde_json::Value),
526}
527
528impl Default for AiTextGenAgent {
529 fn default() -> Self {
530 Self::Unknown(Default::default())
531 }
532}
533
534impl serde::Serialize for AiTextGenAgent {
535 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
536 match self {
537 Self::AiAgentId(inner) => inner.serialize(serializer),
538 Self::AiAgentTextGen(inner) => inner.serialize(serializer),
539 Self::Unknown(inner) => inner.serialize(serializer),
540 }
541 }
542}
543
544impl<'de> serde::Deserialize<'de> for AiTextGenAgent {
545 fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
546 let value = serde_json::Value::deserialize(deserializer)?;
547 let tag = value
548 .get("type")
549 .and_then(serde_json::Value::as_str)
550 .map(str::to_owned);
551 match tag.as_deref() {
552 Some("ai_agent_id") => Ok(Self::AiAgentId(
553 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
554 )),
555 Some("ai_agent_text_gen") => Ok(Self::AiAgentTextGen(
556 serde_json::from_value(value).map_err(serde::de::Error::custom)?,
557 )),
558 _ => Ok(Self::Unknown(value)),
559 }
560 }
561}
562
563#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
564#[serde(transparent)]
565pub struct AiAgentExtractStructuredType(pub String);
566
567impl AiAgentExtractStructuredType {
568 pub const AI_AGENT_EXTRACT_STRUCTURED: &'static str = "ai_agent_extract_structured";
569}
570
571#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
572pub struct AiAgentInfoModels {
573 #[serde(default, skip_serializing_if = "Option::is_none")]
574 pub name: Option<String>,
575 #[serde(default, skip_serializing_if = "Option::is_none")]
576 pub provider: Option<String>,
577 #[serde(default, skip_serializing_if = "Option::is_none")]
578 pub supported_purpose: Option<String>,
579}
580
581#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
582#[serde(transparent)]
583pub struct AiAgentReferenceType(pub String);
584
585impl AiAgentReferenceType {
586 pub const AI_AGENT_ID: &'static str = "ai_agent_id";
587}
588
589#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
590#[serde(transparent)]
591pub struct AiAskMode(pub String);
592
593impl AiAskMode {
594 pub const MULTIPLE_ITEM_QA: &'static str = "multiple_item_qa";
595 pub const SINGLE_ITEM_QA: &'static str = "single_item_qa";
596}
597
598#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
599pub struct AiExtractStructuredMetadataTemplate {
600 #[serde(default, skip_serializing_if = "Option::is_none")]
601 pub template_key: Option<String>,
602 #[serde(default, skip_serializing_if = "Option::is_none")]
603 pub r#type: Option<MetadataTemplateType>,
604 #[serde(default, skip_serializing_if = "Option::is_none")]
605 pub scope: Option<String>,
606}
607
608#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
609pub struct AiExtractStructuredFields {
610 pub key: String,
611 #[serde(default, skip_serializing_if = "Option::is_none")]
612 pub description: Option<String>,
613 #[serde(
614 rename = "displayName",
615 default,
616 skip_serializing_if = "Option::is_none"
617 )]
618 pub display_name: Option<String>,
619 #[serde(default, skip_serializing_if = "Option::is_none")]
620 pub prompt: Option<String>,
621 #[serde(default, skip_serializing_if = "Option::is_none")]
622 pub r#type: Option<String>,
623 #[serde(default, skip_serializing_if = "Option::is_none")]
624 pub options: Option<Vec<FieldsOptions>>,
625 #[serde(default, skip_serializing_if = "Option::is_none")]
626 pub fields: Option<Vec<AiExtractSubField>>,
627 #[serde(default, skip_serializing_if = "Option::is_none")]
628 pub taxonomy_key: Option<String>,
629 #[serde(default, skip_serializing_if = "Option::is_none")]
630 pub namespace: Option<String>,
631 #[serde(default, skip_serializing_if = "Option::is_none")]
632 pub options_rules: Option<AiOptionsRules>,
633}
634
635#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
636#[serde(transparent)]
637pub struct AiItemAskType(pub String);
638
639impl AiItemAskType {
640 pub const FILE: &'static str = "file";
641 pub const HUBS: &'static str = "hubs";
642}
643
644#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
645#[serde(transparent)]
646pub struct AiTaxonomyReferenceType(pub String);
647
648impl AiTaxonomyReferenceType {
649 pub const TAXONOMY: &'static str = "taxonomy";
650}
651
652#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
653pub struct AiTextGenItems {
654 pub id: String,
655 pub r#type: AiCitationType,
656 #[serde(default, skip_serializing_if = "Option::is_none")]
657 pub content: Option<String>,
658}
659
660#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
661#[serde(transparent)]
662pub struct GetAgentDefaultMode(pub String);
663
664impl GetAgentDefaultMode {
665 pub const ASK: &'static str = "ask";
666 pub const TEXT_GEN: &'static str = "text_gen";
667 pub const EXTRACT: &'static str = "extract";
668 pub const EXTRACT_STRUCTURED: &'static str = "extract_structured";
669}