1use serde::{Deserialize, Serialize};
13use serde_json::Value;
14
15#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
21pub struct ModelCapabilities {
22 pub supports_thinking: bool,
24 pub supports_adaptive_thinking: bool,
25 pub supports_isp: bool,
27
28 pub supports_web_search: bool,
30 pub supports_tool_search: bool,
31 pub supports_structured_output: bool,
32
33 pub supports_effort: bool,
35 pub supports_max_effort: bool,
37 pub supports_fast_mode: bool,
39 pub supports_auto_mode: bool,
41
42 pub supports_1m_context: bool,
44 pub supports_prompt_cache: bool,
45 pub supports_cache_editing: bool,
47
48 pub supports_token_efficient: bool,
51 pub supports_redact_thinking: bool,
52
53 pub max_input_tokens: i64,
55 pub max_output_tokens: i64,
56
57 #[serde(default, skip_serializing_if = "Option::is_none")]
59 pub supports_desktop_visual_understanding: Option<bool>,
60
61 #[serde(default, skip_serializing_if = "Option::is_none")]
63 pub supports_image_generation: Option<bool>,
64
65 #[serde(default, skip_serializing_if = "Option::is_none")]
67 pub supports_video_generation: Option<bool>,
68
69 #[serde(default, skip_serializing_if = "Option::is_none")]
71 pub supports_embedding: Option<bool>,
72
73 #[serde(default, skip_serializing_if = "Option::is_none")]
75 pub supports_rerank: Option<bool>,
76}
77
78#[derive(Debug, Clone, Default, Serialize, Deserialize)]
80pub struct ImageGenerationRequest {
81 pub prompt: String,
82 #[serde(default, skip_serializing_if = "Option::is_none")]
84 pub width: Option<i64>,
85 #[serde(default, skip_serializing_if = "Option::is_none")]
87 pub height: Option<i64>,
88 #[serde(default, skip_serializing_if = "Option::is_none")]
89 pub style: Option<String>,
90}
91
92#[derive(Debug, Clone, Default, Serialize, Deserialize)]
94pub struct ImageGenerationResponse {
95 #[serde(default, skip_serializing_if = "Option::is_none")]
96 pub url: Option<String>,
97 #[serde(default, skip_serializing_if = "Option::is_none")]
98 pub b64_json: Option<String>,
99 #[serde(default, skip_serializing_if = "Option::is_none")]
100 pub revised_prompt: Option<String>,
101 #[serde(rename = "requestId", default, skip_serializing_if = "Option::is_none")]
102 pub request_id: Option<String>,
103}
104
105#[derive(Debug, Clone, Default, Serialize, Deserialize)]
107pub struct VideoGenerationRequest {
108 pub prompt: String,
109 #[serde(default, skip_serializing_if = "Option::is_none")]
110 pub resolution: Option<String>,
111 #[serde(default, skip_serializing_if = "Option::is_none")]
113 pub duration: Option<i64>,
114}
115
116#[derive(Debug, Clone, Default, Serialize, Deserialize)]
118pub struct VideoTaskResponse {
119 #[serde(rename = "taskId")]
120 pub task_id: String,
121 #[serde(default, skip_serializing_if = "Option::is_none")]
123 pub status: Option<String>,
124 #[serde(rename = "videoUrl", default, skip_serializing_if = "Option::is_none")]
125 pub video_url: Option<String>,
126 #[serde(default, skip_serializing_if = "Option::is_none")]
127 pub error: Option<String>,
128 #[serde(rename = "requestId", default, skip_serializing_if = "Option::is_none")]
129 pub request_id: Option<String>,
130}
131
132#[derive(Debug, Clone, Serialize, Deserialize)]
138#[serde(untagged)]
139pub enum EmbeddingInput {
140 Single(String),
142 Batch(Vec<String>),
144}
145
146#[derive(Debug, Clone, Default, Serialize, Deserialize)]
149pub struct MultimodalContent {
150 #[serde(default, skip_serializing_if = "Option::is_none")]
152 pub text: Option<String>,
153 #[serde(default, skip_serializing_if = "Option::is_none")]
155 pub image: Option<String>,
156 #[serde(default, skip_serializing_if = "Option::is_none")]
158 pub video: Option<String>,
159}
160
161#[derive(Debug, Clone, Default, Serialize, Deserialize)]
163pub struct EmbeddingRequest {
164 #[serde(default, skip_serializing_if = "Option::is_none")]
166 pub input: Option<EmbeddingInput>,
167 #[serde(default, skip_serializing_if = "Option::is_none")]
169 pub contents: Option<Vec<MultimodalContent>>,
170 #[serde(default, skip_serializing_if = "Option::is_none")]
172 pub dimensions: Option<i64>,
173 #[serde(default, skip_serializing_if = "Option::is_none")]
175 pub encoding_format: Option<String>,
176 #[serde(default, skip_serializing_if = "Option::is_none")]
178 pub output_type: Option<String>,
179 #[serde(default, skip_serializing_if = "Option::is_none")]
181 pub fps: Option<f64>,
182 #[serde(default, skip_serializing_if = "Option::is_none")]
184 pub enable_fusion: Option<bool>,
185}
186
187#[derive(Debug, Clone, Default, Serialize, Deserialize)]
189pub struct EmbeddingData {
190 #[serde(default)]
191 pub object: String,
192 #[serde(default)]
193 pub index: i64,
194 #[serde(default)]
195 pub embedding: Vec<f64>,
196}
197
198#[derive(Debug, Clone, Default, Serialize, Deserialize)]
200pub struct EmbeddingUsage {
201 #[serde(default)]
202 pub prompt_tokens: i64,
203 #[serde(default)]
204 pub total_tokens: i64,
205}
206
207#[derive(Debug, Clone, Default, Serialize, Deserialize)]
209pub struct EmbeddingResponse {
210 #[serde(default)]
211 pub object: String,
212 #[serde(default)]
213 pub model: String,
214 #[serde(default)]
215 pub data: Vec<EmbeddingData>,
216 #[serde(default)]
217 pub usage: EmbeddingUsage,
218 #[serde(default, skip_serializing_if = "Option::is_none")]
219 pub id: Option<String>,
220}
221
222#[derive(Debug, Clone, Serialize, Deserialize)]
224#[serde(untagged)]
225pub enum RerankQuery {
226 Text(String),
228 Multimodal(MultimodalContent),
230}
231
232impl From<String> for RerankQuery {
233 fn from(s: String) -> Self {
234 RerankQuery::Text(s)
235 }
236}
237impl From<&str> for RerankQuery {
238 fn from(s: &str) -> Self {
239 RerankQuery::Text(s.to_string())
240 }
241}
242impl From<MultimodalContent> for RerankQuery {
243 fn from(c: MultimodalContent) -> Self {
244 RerankQuery::Multimodal(c)
245 }
246}
247
248#[derive(Debug, Clone, Serialize, Deserialize)]
250#[serde(untagged)]
251pub enum RerankDocument {
252 Text(String),
254 Multimodal(MultimodalContent),
256}
257
258impl From<String> for RerankDocument {
259 fn from(s: String) -> Self {
260 RerankDocument::Text(s)
261 }
262}
263impl From<&str> for RerankDocument {
264 fn from(s: &str) -> Self {
265 RerankDocument::Text(s.to_string())
266 }
267}
268impl From<MultimodalContent> for RerankDocument {
269 fn from(c: MultimodalContent) -> Self {
270 RerankDocument::Multimodal(c)
271 }
272}
273
274#[derive(Debug, Clone, Serialize, Deserialize)]
276pub struct RerankRequest {
277 pub query: RerankQuery,
279 pub documents: Vec<RerankDocument>,
281 #[serde(default, skip_serializing_if = "Option::is_none")]
283 pub top_n: Option<i64>,
284 #[serde(default, skip_serializing_if = "Option::is_none")]
286 pub return_documents: Option<bool>,
287 #[serde(default, skip_serializing_if = "Option::is_none")]
289 pub instruct: Option<String>,
290 #[serde(default, skip_serializing_if = "Option::is_none")]
292 pub fps: Option<f64>,
293}
294
295#[derive(Debug, Clone, Default, Serialize, Deserialize)]
297pub struct RerankResult {
298 #[serde(default)]
300 pub index: i64,
301 #[serde(default)]
303 pub relevance_score: f64,
304 #[serde(default, skip_serializing_if = "Option::is_none")]
306 pub document: Option<String>,
307}
308
309#[derive(Debug, Clone, Default, Serialize, Deserialize)]
311pub struct RerankResponse {
312 #[serde(default)]
313 pub results: Vec<RerankResult>,
314 #[serde(default)]
315 pub usage: EmbeddingUsage,
316 #[serde(default, skip_serializing_if = "Option::is_none")]
317 pub model: Option<String>,
318}
319
320#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
322#[serde(rename_all = "lowercase")]
323pub enum InputModality {
324 Text,
326 Image,
328}
329
330impl InputModality {
331 pub fn as_str(&self) -> &'static str {
333 match self {
334 InputModality::Text => "text",
335 InputModality::Image => "image",
336 }
337 }
338}
339
340pub const BUCKET_CLASS_COMMERCIAL: &str = "COMMERCIAL";
342pub const BUCKET_CLASS_GENERIC: &str = "GENERIC";
344
345#[derive(Debug, Clone, Default, Serialize, Deserialize)]
347pub struct BucketInfo {
348 #[serde(rename = "quotaEtu")]
349 pub quota_etu: i64,
350 #[serde(rename = "usedEtu")]
351 pub used_etu: i64,
352 #[serde(rename = "remainingEtu")]
353 pub remaining_etu: i64,
354 #[serde(
355 rename = "sharedPoolEtu",
356 default,
357 skip_serializing_if = "Option::is_none"
358 )]
359 pub shared_pool_etu: Option<i64>,
360 #[serde(rename = "expiresAt", default, skip_serializing_if = "Option::is_none")]
361 pub expires_at: Option<String>,
362 #[serde(rename = "bucketClass")]
363 pub bucket_class: String,
364 #[serde(default, skip_serializing_if = "Option::is_none")]
365 pub expired: Option<bool>,
366 #[serde(rename = "freeRemainingEtu")]
368 pub free_remaining_etu: i64,
369 #[serde(rename = "paidRemainingEtu")]
371 pub paid_remaining_etu: i64,
372}
373
374pub fn bucket_info_is_commercial(b: Option<&BucketInfo>) -> bool {
376 match b {
377 None => false,
378 Some(b) => b.bucket_class.to_lowercase() == BUCKET_CLASS_COMMERCIAL.to_lowercase(),
379 }
380}
381
382#[derive(Debug, Clone, Default, Serialize, Deserialize)]
384pub struct ManagedModel {
385 #[serde(default, skip_serializing_if = "Option::is_none")]
388 pub thinking_levels: Option<Vec<String>>,
389 pub id: String,
390 pub name: String,
391 pub provider: String,
392 #[serde(rename = "modelId")]
393 pub model_id: String,
394 #[serde(rename = "maxTokens")]
395 pub max_tokens: i64,
396 #[serde(rename = "isEnabled")]
397 pub is_enabled: bool,
398 #[serde(
400 rename = "pricePerMTok",
401 default,
402 skip_serializing_if = "Option::is_none"
403 )]
404 pub price_per_m_tok: Option<f64>,
405 #[serde(rename = "isDefault", default, skip_serializing_if = "Option::is_none")]
407 pub is_default: Option<bool>,
408 #[serde(
409 rename = "contextWindow",
410 default,
411 skip_serializing_if = "Option::is_none"
412 )]
413 pub context_window: Option<i64>,
414 pub capabilities: ModelCapabilities,
415
416 #[serde(
418 rename = "minPlanTier",
419 default,
420 skip_serializing_if = "Option::is_none"
421 )]
422 pub min_plan_tier: Option<i64>,
423 #[serde(
425 rename = "chatRuntimeSupported",
426 default,
427 skip_serializing_if = "Option::is_none"
428 )]
429 pub chat_runtime_supported: Option<bool>,
430 #[serde(
432 rename = "defaultToolIds",
433 default,
434 skip_serializing_if = "Option::is_none"
435 )]
436 pub default_tool_ids: Option<Vec<String>>,
437 #[serde(default, skip_serializing_if = "Option::is_none")]
439 pub locked: Option<bool>,
440 #[serde(rename = "freeTier", default, skip_serializing_if = "Option::is_none")]
446 pub free_tier: Option<bool>,
447 #[serde(
453 rename = "freePoolEligible",
454 default,
455 skip_serializing_if = "Option::is_none"
456 )]
457 pub free_pool_eligible: Option<bool>,
458
459 #[serde(default, skip_serializing_if = "Option::is_none")]
462 pub supported_formats: Option<Vec<String>>,
463
464 #[serde(default, skip_serializing_if = "Option::is_none")]
466 pub preferred_format: Option<String>,
467
468 #[serde(
470 rename = "bucketInfo",
471 default,
472 skip_serializing_if = "Option::is_none"
473 )]
474 pub bucket_info: Option<BucketInfo>,
475
476 #[serde(
480 rename = "inputModalities",
481 default,
482 skip_serializing_if = "Option::is_none"
483 )]
484 pub input_modalities: Option<Vec<InputModality>>,
485
486 #[serde(
489 rename = "input_modalities",
490 default,
491 skip_serializing_if = "Option::is_none"
492 )]
493 pub input_modalities_snake: Option<Vec<Value>>,
494}
495
496#[derive(Debug, Clone, Default, Serialize, Deserialize)]
502pub struct BucketRow {
503 #[serde(rename = "bucketId")]
504 pub bucket_id: String,
505 #[serde(rename = "modelId")]
507 pub model_id: String,
508 #[serde(rename = "bucketClass")]
510 pub bucket_class: String,
511 #[serde(rename = "tokenQuota")]
512 pub token_quota: i64,
513 #[serde(rename = "tokenUsed")]
514 pub token_used: i64,
515 #[serde(rename = "tokenRemaining")]
516 pub token_remaining: i64,
517 #[serde(rename = "expiresAt", default, skip_serializing_if = "Option::is_none")]
519 pub expires_at: Option<String>,
520 #[serde(default, skip_serializing_if = "Option::is_none")]
521 pub expired: Option<bool>,
522}
523
524pub fn bucket_row_is_commercial(r: Option<&BucketRow>) -> bool {
526 match r {
527 None => false,
528 Some(r) => r.bucket_class.to_lowercase() == BUCKET_CLASS_COMMERCIAL.to_lowercase(),
529 }
530}
531
532#[derive(Debug, Clone, Default, Serialize, Deserialize)]
540pub struct QuotaSummarySubscriptionPool {
541 pub quota: i64,
542 pub used: i64,
543 pub remaining: i64,
544 #[serde(rename = "expiresAt", default, skip_serializing_if = "Option::is_none")]
545 pub expires_at: Option<String>,
546 pub unit: String,
548 #[serde(
549 rename = "boosterRemaining",
550 default,
551 skip_serializing_if = "Option::is_none"
552 )]
553 pub booster_remaining: Option<i64>,
554 #[serde(
555 rename = "boosterCount",
556 default,
557 skip_serializing_if = "Option::is_none"
558 )]
559 pub booster_count: Option<i64>,
560 #[serde(
561 rename = "boosterNextExpiresAt",
562 default,
563 skip_serializing_if = "Option::is_none"
564 )]
565 pub booster_next_expires_at: Option<String>,
566}
567
568#[derive(Debug, Clone, Default, Serialize, Deserialize)]
575pub struct QuotaSummaryFreePool {
576 pub quota: i64,
577 pub used: i64,
578 pub remaining: i64,
579 #[serde(rename = "expiresAt", default, skip_serializing_if = "Option::is_none")]
580 pub expires_at: Option<String>,
581 pub unit: String,
583 #[serde(rename = "eligibleModels", default)]
584 pub eligible_models: Vec<String>,
585}
586
587#[derive(Debug, Clone, Default, Serialize, Deserialize)]
589pub struct WindowLimitStatus {
590 pub kind: String,
592 #[serde(rename = "limitCredits")]
593 pub limit_credits: i64,
594 #[serde(rename = "usedCredits")]
595 pub used_credits: i64,
596 #[serde(rename = "resetAt", default, skip_serializing_if = "Option::is_none")]
598 pub reset_at: Option<String>,
599 #[serde(default, skip_serializing_if = "Option::is_none")]
601 pub overridable: Option<bool>,
602 #[serde(
604 rename = "fiveHourSoftContinuing",
605 default,
606 skip_serializing_if = "Option::is_none"
607 )]
608 pub five_hour_soft_continuing: Option<bool>,
609 #[serde(
611 rename = "inflightHeldCredits",
612 default,
613 skip_serializing_if = "Option::is_none"
614 )]
615 pub inflight_held_credits: Option<i64>,
616}
617
618#[derive(Debug, Clone, Default, Serialize, Deserialize)]
627pub struct QuotaSummary {
628 #[serde(rename = "freeTotalEtu")]
630 pub free_total_etu: i64,
631 #[serde(rename = "paidTotalEtu")]
633 pub paid_total_etu: i64,
634 #[serde(rename = "freeBuckets", default)]
636 pub free_buckets: Vec<BucketRow>,
637 #[serde(rename = "paidBuckets", default)]
639 pub paid_buckets: Vec<BucketRow>,
640 #[serde(
642 rename = "nextFreeExpiresAt",
643 default,
644 skip_serializing_if = "Option::is_none"
645 )]
646 pub next_free_expires_at: Option<String>,
647 #[serde(
649 rename = "nextPaidExpiresAt",
650 default,
651 skip_serializing_if = "Option::is_none"
652 )]
653 pub next_paid_expires_at: Option<String>,
654 #[serde(
656 rename = "subscriptionPool",
657 default,
658 skip_serializing_if = "Option::is_none"
659 )]
660 pub subscription_pool: Option<QuotaSummarySubscriptionPool>,
661 #[serde(
663 rename = "windowLimits",
664 default,
665 skip_serializing_if = "Option::is_none"
666 )]
667 pub window_limits: Option<Vec<WindowLimitStatus>>,
668 #[serde(
670 rename = "windowFiveHourContinueEnabled",
671 default,
672 skip_serializing_if = "Option::is_none"
673 )]
674 pub window_five_hour_continue_enabled: Option<bool>,
675 #[serde(rename = "freePool", default, skip_serializing_if = "Option::is_none")]
681 pub free_pool: Option<QuotaSummaryFreePool>,
682 #[serde(
688 rename = "creditUnit",
689 default,
690 skip_serializing_if = "Option::is_none"
691 )]
692 pub credit_unit: Option<String>,
693}
694
695pub const QUOTA_UNIT_MICRO_CREDIT: &str = "MICRO_CREDIT";
697pub const CREDIT_UNIT_OFFICIAL_CNY: &str = "OFFICIAL_CNY";
699pub const CREDIT_UNIT_COST_CNY: &str = "COST_CNY";
701
702#[derive(Debug, Clone, Default, Serialize, Deserialize)]
708pub struct ChatMessage {
709 pub role: String,
710 pub content: String,
711}
712
713#[derive(Debug, Clone, Default, Serialize, Deserialize)]
716pub struct ChatContentBlock {
717 pub r#type: String,
718 #[serde(default, skip_serializing_if = "Option::is_none")]
719 pub text: Option<String>,
720 #[serde(default, skip_serializing_if = "Option::is_none")]
721 pub citations: Option<Value>,
722 #[serde(default, skip_serializing_if = "Option::is_none")]
723 pub thinking: Option<String>,
724 #[serde(default, skip_serializing_if = "Option::is_none")]
725 pub signature: Option<String>,
726 #[serde(default, skip_serializing_if = "Option::is_none")]
727 pub data: Option<String>,
728 #[serde(default, skip_serializing_if = "Option::is_none")]
729 pub id: Option<String>,
730 #[serde(default, skip_serializing_if = "Option::is_none")]
731 pub name: Option<String>,
732 #[serde(default, skip_serializing_if = "Option::is_none")]
734 pub input: Option<Value>,
735 #[serde(default, skip_serializing_if = "Option::is_none")]
736 pub server_name: Option<String>,
737 #[serde(default, skip_serializing_if = "Option::is_none")]
738 pub caller: Option<Value>,
739 #[serde(default, skip_serializing_if = "Option::is_none")]
740 pub tool_use_id: Option<String>,
741 #[serde(default, skip_serializing_if = "Option::is_none")]
742 pub content: Option<Value>,
743 #[serde(default, skip_serializing_if = "Option::is_none")]
744 pub is_error: Option<bool>,
745}
746
747#[derive(Debug, Clone, Default, Serialize, Deserialize)]
749pub struct ChatUsage {
750 pub input_tokens: i64,
751 pub output_tokens: i64,
752 #[serde(default, skip_serializing_if = "Option::is_none")]
753 pub cache_creation_input_tokens: Option<i64>,
754 #[serde(default, skip_serializing_if = "Option::is_none")]
755 pub cache_read_input_tokens: Option<i64>,
756}
757
758pub const THINKING_OFF: &str = "off";
762pub const THINKING_LOW: &str = "low";
763pub const THINKING_HIGH: &str = "high";
765pub const THINKING_MAX: &str = "max";
767
768pub const THINKING_HIGH_MIN_MAX_TOKENS: i64 = 32_000;
770pub const THINKING_MAX_FALLBACK_MAX_TOKENS: i64 = 128_000;
772
773#[derive(Debug, Clone, Default, Serialize, Deserialize)]
775pub struct ThinkingConfig {
776 pub r#type: String,
778 #[serde(default, skip_serializing_if = "Option::is_none")]
780 pub budget_tokens: Option<i64>,
781 #[serde(default, skip_serializing_if = "Option::is_none")]
783 pub level: Option<String>,
784 #[serde(default, skip_serializing_if = "Option::is_none")]
786 pub display: Option<String>,
787}
788
789pub fn new_thinking_config(level: &str) -> ThinkingConfig {
791 if level.is_empty() || level == THINKING_OFF {
792 return ThinkingConfig {
793 r#type: "disabled".to_string(),
794 ..Default::default()
795 };
796 }
797 ThinkingConfig {
798 r#type: "adaptive".to_string(),
799 level: Some(level.to_string()),
800 ..Default::default()
801 }
802}
803
804#[derive(Debug, Clone, Default, Serialize, Deserialize)]
806pub struct ServerTool {
807 pub r#type: String,
808 pub name: String,
809 #[serde(default, skip_serializing_if = "Option::is_none")]
810 pub config: Option<serde_json::Map<String, Value>>,
811}
812
813pub const SERVER_TOOL_TYPE_WEB_SEARCH: &str = "web_search_20250305";
815
816#[derive(Debug, Clone, Default, Serialize, Deserialize)]
818pub struct GeoLoc {
819 pub country: String,
821 #[serde(default, skip_serializing_if = "Option::is_none")]
822 pub city: Option<String>,
823}
824
825#[derive(Debug, Clone, Default, Serialize, Deserialize)]
827pub struct WebSearchConfig {
828 #[serde(default, skip_serializing_if = "Option::is_none")]
830 pub max_uses: Option<i64>,
831 #[serde(default, skip_serializing_if = "Option::is_none")]
833 pub allowed_domains: Option<Vec<String>>,
834 #[serde(default, skip_serializing_if = "Option::is_none")]
836 pub blocked_domains: Option<Vec<String>>,
837 #[serde(default, skip_serializing_if = "Option::is_none")]
838 pub user_location: Option<GeoLoc>,
839}
840
841#[derive(Debug, Clone, Default, Serialize, Deserialize)]
843pub struct EffortConfig {
844 pub level: String,
846}
847
848#[derive(Debug, Clone, Default, Serialize, Deserialize)]
850pub struct OutputConfig {
851 #[serde(default, skip_serializing_if = "Option::is_none")]
853 pub format: Option<String>,
854 #[serde(default, skip_serializing_if = "Option::is_none")]
855 pub schema: Option<Value>,
856}
857
858pub fn new_web_search_tool(
861 cfg: Option<&WebSearchConfig>,
862) -> crate::shared::errors::Result<ServerTool> {
863 let mut st = ServerTool {
864 r#type: SERVER_TOOL_TYPE_WEB_SEARCH.to_string(),
865 name: "web_search".to_string(),
866 config: None,
867 };
868 if let Some(cfg) = cfg {
869 let allowed_len = cfg.allowed_domains.as_ref().map(|v| v.len()).unwrap_or(0);
870 let blocked_len = cfg.blocked_domains.as_ref().map(|v| v.len()).unwrap_or(0);
871 if allowed_len > 0 && blocked_len > 0 {
872 return Err(crate::shared::errors::Error::other(
873 "web search: allowed_domains and blocked_domains are mutually exclusive",
874 ));
875 }
876 let mut m = serde_json::Map::new();
877 if let Some(mu) = cfg.max_uses {
878 if mu > 0 {
879 m.insert("max_uses".to_string(), Value::from(mu));
880 }
881 }
882 if allowed_len > 0 {
883 m.insert(
884 "allowed_domains".to_string(),
885 serde_json::to_value(cfg.allowed_domains.as_ref().unwrap())?,
886 );
887 }
888 if blocked_len > 0 {
889 m.insert(
890 "blocked_domains".to_string(),
891 serde_json::to_value(cfg.blocked_domains.as_ref().unwrap())?,
892 );
893 }
894 if let Some(loc) = &cfg.user_location {
895 m.insert("user_location".to_string(), serde_json::to_value(loc)?);
896 }
897 if !m.is_empty() {
898 st.config = Some(m);
899 }
900 }
901 Ok(st)
902}
903
904#[derive(Debug, Clone, Default)]
909pub struct ChatRequest {
910 pub messages: Option<Vec<ChatMessage>>,
912 pub stream: Option<bool>,
913 pub max_tokens: Option<i64>,
914
915 pub raw_messages: Option<Value>,
918 pub system: Option<Value>,
920 pub tools: Option<Value>,
922 pub temperature: Option<f64>,
923 pub thinking: Option<ThinkingConfig>,
924 pub metadata: Option<std::collections::BTreeMap<String, String>>,
925 pub betas: Option<Vec<String>>,
927 pub server_tools: Option<Vec<ServerTool>>,
929 pub speed: Option<String>,
931 pub effort: Option<EffortConfig>,
932 pub output_config: Option<OutputConfig>,
933 pub extra_body: Option<serde_json::Map<String, Value>>,
935
936 pub parallel_tool_calls: Option<bool>,
939
940 pub end_user_id: Option<String>,
943}
944
945#[derive(Debug, Clone, Default, Serialize, Deserialize)]
949pub struct WebSearchSource {
950 pub title: String,
951 pub url: String,
952 #[serde(default, skip_serializing_if = "Option::is_none")]
953 pub snippet: Option<String>,
954}
955
956#[derive(Debug, Clone, Default, Serialize, Deserialize)]
958pub struct SourcesEvent {
959 pub sources: Vec<WebSearchSource>,
960 #[serde(default, skip_serializing_if = "Option::is_none")]
961 pub session_id: Option<String>,
962}
963
964#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
966#[serde(rename_all = "snake_case")]
967pub enum SourcesEventIssueCode {
968 InvalidJson,
969 MissingSources,
970 SourcesNotArray,
971 SourceNotObject,
972 SourceTitleInvalid,
973 SourceUrlInvalid,
974 SourceSnippetInvalid,
975 SessionIdInvalid,
976}
977
978#[derive(Debug, Clone, Serialize, Deserialize)]
980#[serde(tag = "kind", rename_all = "snake_case")]
981pub enum SourcesEventParseResult {
982 NotSources,
983 EmptySources {
984 #[serde(skip_serializing_if = "Option::is_none")]
985 session_id: Option<String>,
986 },
987 Sources {
988 value: SourcesEvent,
989 },
990 MalformedSources {
991 code: SourcesEventIssueCode,
992 },
993}
994
995pub fn classify_sources_event(ev: &StreamEvent) -> SourcesEventParseResult {
998 use SourcesEventIssueCode::*;
999 use SourcesEventParseResult::*;
1000 let malformed = |code| MalformedSources { code };
1001 let value: Value = match serde_json::from_str(&ev.data) {
1002 Ok(value) => value,
1003 Err(_) if ev.event == "sources" => return malformed(InvalidJson),
1004 Err(_) => return NotSources,
1005 };
1006 if ev.event != "sources" && value.get("type").and_then(Value::as_str) != Some("sources") {
1007 return NotSources;
1008 }
1009 let Some(raw_sources) = value.as_object().and_then(|v| v.get("sources")) else {
1010 return malformed(MissingSources);
1011 };
1012 let session_id = match value.get("session_id") {
1013 None => None,
1014 Some(Value::String(s)) => Some(s.clone()),
1015 Some(_) => return malformed(SessionIdInvalid),
1016 };
1017 let Some(raw_sources) = raw_sources.as_array() else {
1018 return malformed(SourcesNotArray);
1019 };
1020 if raw_sources.is_empty() {
1021 return EmptySources { session_id };
1022 }
1023 let mut sources = Vec::with_capacity(raw_sources.len());
1024 for source in raw_sources {
1025 if !source.is_object() {
1026 return malformed(SourceNotObject);
1027 }
1028 let Some(title) = source.get("title").and_then(Value::as_str) else {
1029 return malformed(SourceTitleInvalid);
1030 };
1031 let Some(url) = source.get("url").and_then(Value::as_str) else {
1032 return malformed(SourceUrlInvalid);
1033 };
1034 let snippet = match source.get("snippet") {
1035 None => None,
1036 Some(Value::String(s)) => Some(s.clone()),
1037 Some(_) => return malformed(SourceSnippetInvalid),
1038 };
1039 sources.push(WebSearchSource {
1040 title: title.into(),
1041 url: url.into(),
1042 snippet,
1043 });
1044 }
1045 Sources {
1046 value: SourcesEvent {
1047 sources,
1048 session_id,
1049 },
1050 }
1051}
1052
1053pub fn parse_sources_event(ev: &StreamEvent) -> Option<SourcesEvent> {
1055 #[derive(Deserialize)]
1056 struct Wrapper {
1057 #[serde(default)]
1058 r#type: Option<String>,
1059 #[serde(default)]
1060 sources: Option<Vec<WebSearchSource>>,
1061 #[serde(default)]
1062 session_id: Option<String>,
1063 }
1064 let wrapper: Wrapper = serde_json::from_str(&ev.data).ok()?;
1065 if wrapper.r#type.as_deref() != Some("sources") && ev.event != "sources" {
1066 return None;
1067 }
1068 let sources = wrapper.sources.filter(|s| !s.is_empty())?;
1069 Some(SourcesEvent {
1070 sources,
1071 session_id: wrapper.session_id,
1072 })
1073}
1074
1075#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1084pub struct ChatResponse {
1085 pub id: String,
1086 pub r#type: String,
1087 pub model: String,
1088 pub role: String,
1089 pub content: Vec<ChatContentBlock>,
1090 pub stop_reason: String,
1091 pub usage: ChatUsage,
1092 #[serde(rename = "tokenRemaining", default)]
1094 pub token_remaining: i64,
1095 #[serde(rename = "callRemaining", default)]
1096 pub call_remaining: i64,
1097 #[serde(rename = "modelTokenRemaining", default)]
1098 pub model_token_remaining: i64,
1099 #[serde(rename = "modelTokenRemainingETU", default)]
1100 pub model_token_remaining_etu: i64,
1101}
1102
1103#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1112pub struct StreamEvent {
1113 pub event: String,
1114 pub data: String,
1115 #[serde(
1117 rename = "blockIndex",
1118 default,
1119 skip_serializing_if = "Option::is_none"
1120 )]
1121 pub block_index: Option<i64>,
1122 #[serde(rename = "blockType", default, skip_serializing_if = "Option::is_none")]
1124 pub block_type: Option<String>,
1125 #[serde(default, skip_serializing_if = "Option::is_none")]
1127 pub ephemeral: Option<bool>,
1128}
1129
1130#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1132pub struct StreamSettlement {
1133 #[serde(rename = "requestId")]
1134 pub request_id: String,
1135 #[serde(rename = "consumeStatus")]
1136 pub consume_status: String,
1137 #[serde(rename = "inputTokens")]
1138 pub input_tokens: i64,
1139 #[serde(rename = "outputTokens")]
1140 pub output_tokens: i64,
1141 #[serde(rename = "totalTokens")]
1142 pub total_tokens: i64,
1143 #[serde(rename = "tokenRemaining")]
1145 pub token_remaining: i64,
1146 #[serde(rename = "callRemaining")]
1148 pub call_remaining: i64,
1149}
1150
1151pub fn parse_settlement(ev: &StreamEvent) -> Option<StreamSettlement> {
1153 if ev.event != "settled" && ev.event != "pending_settle" {
1154 return None;
1155 }
1156 #[derive(Deserialize)]
1158 struct Partial {
1159 #[serde(rename = "requestId", default)]
1160 request_id: Option<String>,
1161 #[serde(rename = "consumeStatus", default)]
1162 consume_status: Option<String>,
1163 #[serde(rename = "inputTokens", default)]
1164 input_tokens: Option<i64>,
1165 #[serde(rename = "outputTokens", default)]
1166 output_tokens: Option<i64>,
1167 #[serde(rename = "totalTokens", default)]
1168 total_tokens: Option<i64>,
1169 #[serde(rename = "tokenRemaining", default)]
1170 token_remaining: Option<i64>,
1171 #[serde(rename = "callRemaining", default)]
1172 call_remaining: Option<i64>,
1173 }
1174 let s: Partial = serde_json::from_str(&ev.data).ok()?;
1175 Some(StreamSettlement {
1176 request_id: s.request_id.unwrap_or_default(),
1177 consume_status: s.consume_status.unwrap_or_default(),
1178 input_tokens: s.input_tokens.unwrap_or(0),
1179 output_tokens: s.output_tokens.unwrap_or(0),
1180 total_tokens: s.total_tokens.unwrap_or(0),
1181 token_remaining: s.token_remaining.unwrap_or(-1),
1182 call_remaining: s.call_remaining.unwrap_or(-1),
1183 })
1184}
1185
1186pub fn zero_model_capabilities() -> ModelCapabilities {
1188 ModelCapabilities {
1189 supports_desktop_visual_understanding: Some(false),
1190 ..Default::default()
1191 }
1192}