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, Serialize, Deserialize)]
pub struct EmbeddingRequest {
pub input: EmbeddingInput,
#[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>,
}
#[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)]
pub struct RerankRequest {
pub query: String,
pub documents: Vec<String>,
#[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>,
}
#[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 {
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(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 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>,
}
#[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_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>,
}
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()
}
}