use serde::{Deserialize, Serialize};
use serde_json::Value;
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ModelCapabilities {
pub supports_thinking: bool,
pub supports_adaptive_thinking: bool,
pub supports_isp: bool,
pub supports_web_search: bool,
pub supports_tool_search: bool,
pub supports_structured_output: bool,
pub supports_effort: bool,
pub supports_max_effort: bool,
pub supports_fast_mode: bool,
pub supports_auto_mode: bool,
pub supports_1m_context: bool,
pub supports_prompt_cache: bool,
pub supports_cache_editing: bool,
pub supports_token_efficient: bool,
pub supports_redact_thinking: bool,
pub max_input_tokens: i64,
pub max_output_tokens: i64,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub supports_desktop_visual_understanding: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub supports_image_generation: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub supports_video_generation: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub supports_embedding: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub supports_rerank: Option<bool>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ImageGenerationRequest {
pub prompt: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub width: Option<i64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub height: Option<i64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub style: Option<String>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ImageGenerationResponse {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub url: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub b64_json: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub revised_prompt: Option<String>,
#[serde(rename = "requestId", default, skip_serializing_if = "Option::is_none")]
pub request_id: Option<String>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct VideoGenerationRequest {
pub prompt: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub resolution: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub duration: Option<i64>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct VideoTaskResponse {
#[serde(rename = "taskId")]
pub task_id: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "videoUrl", default, skip_serializing_if = "Option::is_none")]
pub video_url: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub error: Option<String>,
#[serde(rename = "requestId", default, skip_serializing_if = "Option::is_none")]
pub request_id: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum EmbeddingInput {
Single(String),
Batch(Vec<String>),
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct MultimodalContent {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub text: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub image: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub video: Option<String>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct EmbeddingRequest {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub input: Option<EmbeddingInput>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub contents: Option<Vec<MultimodalContent>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub dimensions: Option<i64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub encoding_format: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub output_type: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub fps: Option<f64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub enable_fusion: Option<bool>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct EmbeddingData {
#[serde(default)]
pub object: String,
#[serde(default)]
pub index: i64,
#[serde(default)]
pub embedding: Vec<f64>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct EmbeddingUsage {
#[serde(default)]
pub prompt_tokens: i64,
#[serde(default)]
pub total_tokens: i64,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct EmbeddingResponse {
#[serde(default)]
pub object: String,
#[serde(default)]
pub model: String,
#[serde(default)]
pub data: Vec<EmbeddingData>,
#[serde(default)]
pub usage: EmbeddingUsage,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum RerankQuery {
Text(String),
Multimodal(MultimodalContent),
}
impl From<String> for RerankQuery {
fn from(s: String) -> Self {
RerankQuery::Text(s)
}
}
impl From<&str> for RerankQuery {
fn from(s: &str) -> Self {
RerankQuery::Text(s.to_string())
}
}
impl From<MultimodalContent> for RerankQuery {
fn from(c: MultimodalContent) -> Self {
RerankQuery::Multimodal(c)
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum RerankDocument {
Text(String),
Multimodal(MultimodalContent),
}
impl From<String> for RerankDocument {
fn from(s: String) -> Self {
RerankDocument::Text(s)
}
}
impl From<&str> for RerankDocument {
fn from(s: &str) -> Self {
RerankDocument::Text(s.to_string())
}
}
impl From<MultimodalContent> for RerankDocument {
fn from(c: MultimodalContent) -> Self {
RerankDocument::Multimodal(c)
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RerankRequest {
pub query: RerankQuery,
pub documents: Vec<RerankDocument>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub top_n: Option<i64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub return_documents: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub instruct: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub fps: Option<f64>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct RerankResult {
#[serde(default)]
pub index: i64,
#[serde(default)]
pub relevance_score: f64,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub document: Option<String>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct RerankResponse {
#[serde(default)]
pub results: Vec<RerankResult>,
#[serde(default)]
pub usage: EmbeddingUsage,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub model: Option<String>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum InputModality {
Text,
Image,
}
impl InputModality {
pub fn as_str(&self) -> &'static str {
match self {
InputModality::Text => "text",
InputModality::Image => "image",
}
}
}
pub const BUCKET_CLASS_COMMERCIAL: &str = "COMMERCIAL";
pub const BUCKET_CLASS_GENERIC: &str = "GENERIC";
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct BucketInfo {
#[serde(rename = "quotaEtu")]
pub quota_etu: i64,
#[serde(rename = "usedEtu")]
pub used_etu: i64,
#[serde(rename = "remainingEtu")]
pub remaining_etu: i64,
#[serde(
rename = "sharedPoolEtu",
default,
skip_serializing_if = "Option::is_none"
)]
pub shared_pool_etu: Option<i64>,
#[serde(rename = "expiresAt", default, skip_serializing_if = "Option::is_none")]
pub expires_at: Option<String>,
#[serde(rename = "bucketClass")]
pub bucket_class: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub expired: Option<bool>,
#[serde(rename = "freeRemainingEtu")]
pub free_remaining_etu: i64,
#[serde(rename = "paidRemainingEtu")]
pub paid_remaining_etu: i64,
}
pub fn bucket_info_is_commercial(b: Option<&BucketInfo>) -> bool {
match b {
None => false,
Some(b) => b.bucket_class.to_lowercase() == BUCKET_CLASS_COMMERCIAL.to_lowercase(),
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ManagedModel {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub thinking_levels: Option<Vec<String>>,
pub id: String,
pub name: String,
pub provider: String,
#[serde(rename = "modelId")]
pub model_id: String,
#[serde(rename = "maxTokens")]
pub max_tokens: i64,
#[serde(rename = "isEnabled")]
pub is_enabled: bool,
#[serde(
rename = "pricePerMTok",
default,
skip_serializing_if = "Option::is_none"
)]
pub price_per_m_tok: Option<f64>,
#[serde(rename = "isDefault", default, skip_serializing_if = "Option::is_none")]
pub is_default: Option<bool>,
#[serde(
rename = "contextWindow",
default,
skip_serializing_if = "Option::is_none"
)]
pub context_window: Option<i64>,
pub capabilities: ModelCapabilities,
#[serde(
rename = "minPlanTier",
default,
skip_serializing_if = "Option::is_none"
)]
pub min_plan_tier: Option<i64>,
#[serde(
rename = "chatRuntimeSupported",
default,
skip_serializing_if = "Option::is_none"
)]
pub chat_runtime_supported: Option<bool>,
#[serde(
rename = "defaultToolIds",
default,
skip_serializing_if = "Option::is_none"
)]
pub default_tool_ids: Option<Vec<String>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub locked: Option<bool>,
#[serde(rename = "freeTier", default, skip_serializing_if = "Option::is_none")]
pub free_tier: Option<bool>,
#[serde(
rename = "freePoolEligible",
default,
skip_serializing_if = "Option::is_none"
)]
pub free_pool_eligible: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub supported_formats: Option<Vec<String>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub preferred_format: Option<String>,
#[serde(
rename = "bucketInfo",
default,
skip_serializing_if = "Option::is_none"
)]
pub bucket_info: Option<BucketInfo>,
#[serde(
rename = "inputModalities",
default,
skip_serializing_if = "Option::is_none"
)]
pub input_modalities: Option<Vec<InputModality>>,
#[serde(
rename = "input_modalities",
default,
skip_serializing_if = "Option::is_none"
)]
pub input_modalities_snake: Option<Vec<Value>>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct BucketRow {
#[serde(rename = "bucketId")]
pub bucket_id: String,
#[serde(rename = "modelId")]
pub model_id: String,
#[serde(rename = "bucketClass")]
pub bucket_class: String,
#[serde(rename = "tokenQuota")]
pub token_quota: i64,
#[serde(rename = "tokenUsed")]
pub token_used: i64,
#[serde(rename = "tokenRemaining")]
pub token_remaining: i64,
#[serde(rename = "expiresAt", default, skip_serializing_if = "Option::is_none")]
pub expires_at: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub expired: Option<bool>,
}
pub fn bucket_row_is_commercial(r: Option<&BucketRow>) -> bool {
match r {
None => false,
Some(r) => r.bucket_class.to_lowercase() == BUCKET_CLASS_COMMERCIAL.to_lowercase(),
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct QuotaSummarySubscriptionPool {
pub quota: i64,
pub used: i64,
pub remaining: i64,
#[serde(rename = "expiresAt", default, skip_serializing_if = "Option::is_none")]
pub expires_at: Option<String>,
pub unit: String,
#[serde(
rename = "boosterRemaining",
default,
skip_serializing_if = "Option::is_none"
)]
pub booster_remaining: Option<i64>,
#[serde(
rename = "boosterCount",
default,
skip_serializing_if = "Option::is_none"
)]
pub booster_count: Option<i64>,
#[serde(
rename = "boosterNextExpiresAt",
default,
skip_serializing_if = "Option::is_none"
)]
pub booster_next_expires_at: Option<String>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct QuotaSummaryFreePool {
pub quota: i64,
pub used: i64,
pub remaining: i64,
#[serde(rename = "expiresAt", default, skip_serializing_if = "Option::is_none")]
pub expires_at: Option<String>,
pub unit: String,
#[serde(rename = "eligibleModels", default)]
pub eligible_models: Vec<String>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct WindowLimitStatus {
pub kind: String,
#[serde(rename = "limitCredits")]
pub limit_credits: i64,
#[serde(rename = "usedCredits")]
pub used_credits: i64,
#[serde(rename = "resetAt", default, skip_serializing_if = "Option::is_none")]
pub reset_at: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub overridable: Option<bool>,
#[serde(
rename = "fiveHourSoftContinuing",
default,
skip_serializing_if = "Option::is_none"
)]
pub five_hour_soft_continuing: Option<bool>,
#[serde(
rename = "inflightHeldCredits",
default,
skip_serializing_if = "Option::is_none"
)]
pub inflight_held_credits: Option<i64>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct QuotaSummary {
#[serde(rename = "freeTotalEtu")]
pub free_total_etu: i64,
#[serde(rename = "paidTotalEtu")]
pub paid_total_etu: i64,
#[serde(rename = "freeBuckets", default)]
pub free_buckets: Vec<BucketRow>,
#[serde(rename = "paidBuckets", default)]
pub paid_buckets: Vec<BucketRow>,
#[serde(
rename = "nextFreeExpiresAt",
default,
skip_serializing_if = "Option::is_none"
)]
pub next_free_expires_at: Option<String>,
#[serde(
rename = "nextPaidExpiresAt",
default,
skip_serializing_if = "Option::is_none"
)]
pub next_paid_expires_at: Option<String>,
#[serde(
rename = "subscriptionPool",
default,
skip_serializing_if = "Option::is_none"
)]
pub subscription_pool: Option<QuotaSummarySubscriptionPool>,
#[serde(
rename = "windowLimits",
default,
skip_serializing_if = "Option::is_none"
)]
pub window_limits: Option<Vec<WindowLimitStatus>>,
#[serde(
rename = "windowFiveHourContinueEnabled",
default,
skip_serializing_if = "Option::is_none"
)]
pub window_five_hour_continue_enabled: Option<bool>,
#[serde(rename = "freePool", default, skip_serializing_if = "Option::is_none")]
pub free_pool: Option<QuotaSummaryFreePool>,
#[serde(
rename = "creditUnit",
default,
skip_serializing_if = "Option::is_none"
)]
pub credit_unit: Option<String>,
}
pub const QUOTA_UNIT_MICRO_CREDIT: &str = "MICRO_CREDIT";
pub const CREDIT_UNIT_OFFICIAL_CNY: &str = "OFFICIAL_CNY";
pub const CREDIT_UNIT_COST_CNY: &str = "COST_CNY";
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ChatMessage {
pub role: String,
pub content: String,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ChatContentBlock {
pub r#type: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub text: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub citations: Option<Value>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub thinking: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub signature: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub data: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub input: Option<Value>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub server_name: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub caller: Option<Value>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub tool_use_id: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub content: Option<Value>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub is_error: Option<bool>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ChatUsage {
pub input_tokens: i64,
pub output_tokens: i64,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub cache_creation_input_tokens: Option<i64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub cache_read_input_tokens: Option<i64>,
}
pub const THINKING_OFF: &str = "off";
pub const THINKING_LOW: &str = "low";
pub const THINKING_HIGH: &str = "high";
pub const THINKING_MAX: &str = "max";
pub const THINKING_HIGH_MIN_MAX_TOKENS: i64 = 32_000;
pub const THINKING_MAX_FALLBACK_MAX_TOKENS: i64 = 128_000;
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ThinkingConfig {
pub r#type: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub budget_tokens: Option<i64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub level: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub display: Option<String>,
}
pub fn new_thinking_config(level: &str) -> ThinkingConfig {
if level.is_empty() || level == THINKING_OFF {
return ThinkingConfig {
r#type: "disabled".to_string(),
..Default::default()
};
}
ThinkingConfig {
r#type: "adaptive".to_string(),
level: Some(level.to_string()),
..Default::default()
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ServerTool {
pub r#type: String,
pub name: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub config: Option<serde_json::Map<String, Value>>,
}
pub const SERVER_TOOL_TYPE_WEB_SEARCH: &str = "web_search_20250305";
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct GeoLoc {
pub country: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub city: Option<String>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct WebSearchConfig {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub max_uses: Option<i64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub allowed_domains: Option<Vec<String>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub blocked_domains: Option<Vec<String>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub user_location: Option<GeoLoc>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct EffortConfig {
pub level: String,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct OutputConfig {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub format: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub schema: Option<Value>,
}
pub fn new_web_search_tool(
cfg: Option<&WebSearchConfig>,
) -> crate::shared::errors::Result<ServerTool> {
let mut st = ServerTool {
r#type: SERVER_TOOL_TYPE_WEB_SEARCH.to_string(),
name: "web_search".to_string(),
config: None,
};
if let Some(cfg) = cfg {
let allowed_len = cfg.allowed_domains.as_ref().map(|v| v.len()).unwrap_or(0);
let blocked_len = cfg.blocked_domains.as_ref().map(|v| v.len()).unwrap_or(0);
if allowed_len > 0 && blocked_len > 0 {
return Err(crate::shared::errors::Error::other(
"web search: allowed_domains and blocked_domains are mutually exclusive",
));
}
let mut m = serde_json::Map::new();
if let Some(mu) = cfg.max_uses {
if mu > 0 {
m.insert("max_uses".to_string(), Value::from(mu));
}
}
if allowed_len > 0 {
m.insert(
"allowed_domains".to_string(),
serde_json::to_value(cfg.allowed_domains.as_ref().unwrap())?,
);
}
if blocked_len > 0 {
m.insert(
"blocked_domains".to_string(),
serde_json::to_value(cfg.blocked_domains.as_ref().unwrap())?,
);
}
if let Some(loc) = &cfg.user_location {
m.insert("user_location".to_string(), serde_json::to_value(loc)?);
}
if !m.is_empty() {
st.config = Some(m);
}
}
Ok(st)
}
#[derive(Debug, Clone, Default)]
pub struct ChatRequest {
pub messages: Option<Vec<ChatMessage>>,
pub stream: Option<bool>,
pub max_tokens: Option<i64>,
pub raw_messages: Option<Value>,
pub system: Option<Value>,
pub tools: Option<Value>,
pub temperature: Option<f64>,
pub thinking: Option<ThinkingConfig>,
pub metadata: Option<std::collections::BTreeMap<String, String>>,
pub betas: Option<Vec<String>>,
pub server_tools: Option<Vec<ServerTool>>,
pub speed: Option<String>,
pub effort: Option<EffortConfig>,
pub output_config: Option<OutputConfig>,
pub extra_body: Option<serde_json::Map<String, Value>>,
pub parallel_tool_calls: Option<bool>,
pub end_user_id: Option<String>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct WebSearchSource {
pub title: String,
pub url: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub snippet: Option<String>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SourcesEvent {
pub sources: Vec<WebSearchSource>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub session_id: Option<String>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum SourcesEventIssueCode {
InvalidJson,
MissingSources,
SourcesNotArray,
SourceNotObject,
SourceTitleInvalid,
SourceUrlInvalid,
SourceSnippetInvalid,
SessionIdInvalid,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "kind", rename_all = "snake_case")]
pub enum SourcesEventParseResult {
NotSources,
EmptySources {
#[serde(skip_serializing_if = "Option::is_none")]
session_id: Option<String>,
},
Sources {
value: SourcesEvent,
},
MalformedSources {
code: SourcesEventIssueCode,
},
}
pub fn classify_sources_event(ev: &StreamEvent) -> SourcesEventParseResult {
use SourcesEventIssueCode::*;
use SourcesEventParseResult::*;
let malformed = |code| MalformedSources { code };
let value: Value = match serde_json::from_str(&ev.data) {
Ok(value) => value,
Err(_) if ev.event == "sources" => return malformed(InvalidJson),
Err(_) => return NotSources,
};
if ev.event != "sources" && value.get("type").and_then(Value::as_str) != Some("sources") {
return NotSources;
}
let Some(raw_sources) = value.as_object().and_then(|v| v.get("sources")) else {
return malformed(MissingSources);
};
let session_id = match value.get("session_id") {
None => None,
Some(Value::String(s)) => Some(s.clone()),
Some(_) => return malformed(SessionIdInvalid),
};
let Some(raw_sources) = raw_sources.as_array() else {
return malformed(SourcesNotArray);
};
if raw_sources.is_empty() {
return EmptySources { session_id };
}
let mut sources = Vec::with_capacity(raw_sources.len());
for source in raw_sources {
if !source.is_object() {
return malformed(SourceNotObject);
}
let Some(title) = source.get("title").and_then(Value::as_str) else {
return malformed(SourceTitleInvalid);
};
let Some(url) = source.get("url").and_then(Value::as_str) else {
return malformed(SourceUrlInvalid);
};
let snippet = match source.get("snippet") {
None => None,
Some(Value::String(s)) => Some(s.clone()),
Some(_) => return malformed(SourceSnippetInvalid),
};
sources.push(WebSearchSource {
title: title.into(),
url: url.into(),
snippet,
});
}
Sources {
value: SourcesEvent {
sources,
session_id,
},
}
}
pub fn parse_sources_event(ev: &StreamEvent) -> Option<SourcesEvent> {
#[derive(Deserialize)]
struct Wrapper {
#[serde(default)]
r#type: Option<String>,
#[serde(default)]
sources: Option<Vec<WebSearchSource>>,
#[serde(default)]
session_id: Option<String>,
}
let wrapper: Wrapper = serde_json::from_str(&ev.data).ok()?;
if wrapper.r#type.as_deref() != Some("sources") && ev.event != "sources" {
return None;
}
let sources = wrapper.sources.filter(|s| !s.is_empty())?;
Some(SourcesEvent {
sources,
session_id: wrapper.session_id,
})
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ChatResponse {
pub id: String,
pub r#type: String,
pub model: String,
pub role: String,
pub content: Vec<ChatContentBlock>,
pub stop_reason: String,
pub usage: ChatUsage,
#[serde(rename = "tokenRemaining", default)]
pub token_remaining: i64,
#[serde(rename = "callRemaining", default)]
pub call_remaining: i64,
#[serde(rename = "modelTokenRemaining", default)]
pub model_token_remaining: i64,
#[serde(rename = "modelTokenRemainingETU", default)]
pub model_token_remaining_etu: i64,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct StreamEvent {
pub event: String,
pub data: String,
#[serde(
rename = "blockIndex",
default,
skip_serializing_if = "Option::is_none"
)]
pub block_index: Option<i64>,
#[serde(rename = "blockType", default, skip_serializing_if = "Option::is_none")]
pub block_type: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub ephemeral: Option<bool>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct StreamSettlement {
#[serde(rename = "requestId")]
pub request_id: String,
#[serde(rename = "consumeStatus")]
pub consume_status: String,
#[serde(rename = "inputTokens")]
pub input_tokens: i64,
#[serde(rename = "outputTokens")]
pub output_tokens: i64,
#[serde(rename = "totalTokens")]
pub total_tokens: i64,
#[serde(rename = "tokenRemaining")]
pub token_remaining: i64,
#[serde(rename = "callRemaining")]
pub call_remaining: i64,
}
pub fn parse_settlement(ev: &StreamEvent) -> Option<StreamSettlement> {
if ev.event != "settled" && ev.event != "pending_settle" {
return None;
}
#[derive(Deserialize)]
struct Partial {
#[serde(rename = "requestId", default)]
request_id: Option<String>,
#[serde(rename = "consumeStatus", default)]
consume_status: Option<String>,
#[serde(rename = "inputTokens", default)]
input_tokens: Option<i64>,
#[serde(rename = "outputTokens", default)]
output_tokens: Option<i64>,
#[serde(rename = "totalTokens", default)]
total_tokens: Option<i64>,
#[serde(rename = "tokenRemaining", default)]
token_remaining: Option<i64>,
#[serde(rename = "callRemaining", default)]
call_remaining: Option<i64>,
}
let s: Partial = serde_json::from_str(&ev.data).ok()?;
Some(StreamSettlement {
request_id: s.request_id.unwrap_or_default(),
consume_status: s.consume_status.unwrap_or_default(),
input_tokens: s.input_tokens.unwrap_or(0),
output_tokens: s.output_tokens.unwrap_or(0),
total_tokens: s.total_tokens.unwrap_or(0),
token_remaining: s.token_remaining.unwrap_or(-1),
call_remaining: s.call_remaining.unwrap_or(-1),
})
}
pub fn zero_model_capabilities() -> ModelCapabilities {
ModelCapabilities {
supports_desktop_visual_understanding: Some(false),
..Default::default()
}
}