refactor(protocols): use serde_with::skip_serializing_none to reduce boilerplate

Cargo.toml

@@ -32,6 +32,7 @@ rand = "0.9.2"
 reqwest = { version = "0.12.8", default-features = false }
 serde = { version = "1.0" }
 serde_json = "1.0"
+serde_with = { version = "3", features = ["macros"] }
 subtle = "2.6"
 thiserror = "2.0.12"
 tokio = { version = "1.42.0" }

protocols/Cargo.toml

@@ -23,6 +23,7 @@ chrono.workspace = true
 rand.workspace = true
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true, features = ["preserve_order"] }
+serde_with.workspace = true
 tokio.workspace = true
 tracing.workspace = true
 # Only used by protocols

protocols/src/chat.rs

@@ -22,31 +22,26 @@ use crate::{
 // Chat Messages
 // ============================================================================
 
+#[serde_with::skip_serializing_none]
 #[derive(Debug, Clone, Deserialize, Serialize)]
 #[serde(tag = "role")]
 pub enum ChatMessage {
     #[serde(rename = "system")]
     System {
         content: MessageContent,
-        #[serde(skip_serializing_if = "Option::is_none")]
         name: Option<String>,
     },
     #[serde(rename = "user")]
     User {
         content: MessageContent,
-        #[serde(skip_serializing_if = "Option::is_none")]
         name: Option<String>,
     },
     #[serde(rename = "assistant")]
     Assistant {
-        #[serde(skip_serializing_if = "Option::is_none")]
         content: Option<MessageContent>,
-        #[serde(skip_serializing_if = "Option::is_none")]
         name: Option<String>,
-        #[serde(skip_serializing_if = "Option::is_none")]
         tool_calls: Option<Vec<ToolCall>>,
         /// Reasoning content for O1-style models (SGLang extension)
-        #[serde(skip_serializing_if = "Option::is_none")]
         reasoning_content: Option<String>,
     },
     #[serde(rename = "tool")]
@@ -59,9 +54,7 @@ pub enum ChatMessage {
     #[serde(rename = "developer")]
     Developer {
         content: MessageContent,
-        #[serde(skip_serializing_if = "Option::is_none")]
         tools: Option<Vec<Tool>>,
-        #[serde(skip_serializing_if = "Option::is_none")]
         name: Option<String>,
     },
 }
@@ -146,6 +139,7 @@ impl MessageContent {
 // Chat Completion Request
 // ============================================================================
 
+#[serde_with::skip_serializing_none]
 #[derive(Debug, Clone, Deserialize, Serialize, Default, Validate)]
 #[validate(schema(function = "validate_chat_cross_parameters"))]
 pub struct ChatCompletionRequest {
@@ -158,88 +152,70 @@ pub struct ChatCompletionRequest {
     pub model: String,
 
     /// Number between -2.0 and 2.0. Positive values penalize new tokens based on their existing frequency in the text so far
-    #[serde(skip_serializing_if = "Option::is_none")]
     #[validate(range(min = -2.0, max = 2.0))]
     pub frequency_penalty: Option<f32>,
 
     /// Deprecated: Replaced by tool_choice
-    #[serde(skip_serializing_if = "Option::is_none")]
     #[deprecated(note = "Use tool_choice instead")]
     pub function_call: Option<FunctionCall>,
 
     /// Deprecated: Replaced by tools
-    #[serde(skip_serializing_if = "Option::is_none")]
     #[deprecated(note = "Use tools instead")]
     pub functions: Option<Vec<Function>>,
 
     /// Modify the likelihood of specified tokens appearing in the completion
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub logit_bias: Option<HashMap<String, f32>>,
 
     /// Whether to return log probabilities of the output tokens
     #[serde(default)]
     pub logprobs: bool,
 
     /// Deprecated: Replaced by max_completion_tokens
-    #[serde(skip_serializing_if = "Option::is_none")]
     #[deprecated(note = "Use max_completion_tokens instead")]
     #[validate(range(min = 1))]
     pub max_tokens: Option<u32>,
 
     /// An upper bound for the number of tokens that can be generated for a completion
-    #[serde(skip_serializing_if = "Option::is_none")]
     #[validate(range(min = 1))]
     pub max_completion_tokens: Option<u32>,
 
     /// Developer-defined tags and values used for filtering completions in the dashboard
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub metadata: Option<HashMap<String, String>>,
 
     /// Output types that you would like the model to generate for this request
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub modalities: Option<Vec<String>>,
 
     /// How many chat completion choices to generate for each input message
-    #[serde(skip_serializing_if = "Option::is_none")]
     #[validate(range(min = 1, max = 10))]
     pub n: Option<u32>,
 
     /// Whether to enable parallel function calling during tool use
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub parallel_tool_calls: Option<bool>,
 
     /// Number between -2.0 and 2.0. Positive values penalize new tokens based on whether they appear in the text so far
-    #[serde(skip_serializing_if = "Option::is_none")]
     #[validate(range(min = -2.0, max = 2.0))]
     pub presence_penalty: Option<f32>,
 
     /// Cache key for prompts (beta feature)
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub prompt_cache_key: Option<String>,
 
     /// Effort level for reasoning models (low, medium, high)
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub reasoning_effort: Option<String>,
 
     /// An object specifying the format that the model must output
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub response_format: Option<ResponseFormat>,
 
     /// Safety identifier for content moderation
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub safety_identifier: Option<String>,
 
     /// Deprecated: This feature is in Legacy mode
-    #[serde(skip_serializing_if = "Option::is_none")]
     #[deprecated(note = "This feature is in Legacy mode")]
     pub seed: Option<i64>,
 
     /// The service tier to use for this request
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub service_tier: Option<String>,
 
     /// Up to 4 sequences where the API will stop generating further tokens
-    #[serde(skip_serializing_if = "Option::is_none")]
     #[validate(custom(function = "validate_stop"))]
     pub stop: Option<StringOrArray>,
 
@@ -248,34 +224,27 @@ pub struct ChatCompletionRequest {
     pub stream: bool,
 
     /// Options for streaming response
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub stream_options: Option<StreamOptions>,
 
     /// What sampling temperature to use, between 0 and 2
-    #[serde(skip_serializing_if = "Option::is_none")]
     #[validate(range(min = 0.0, max = 2.0))]
     pub temperature: Option<f32>,
 
     /// Controls which (if any) tool is called by the model
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub tool_choice: Option<ToolChoice>,
 
     /// A list of tools the model may call
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub tools: Option<Vec<Tool>>,
 
     /// An integer between 0 and 20 specifying the number of most likely tokens to return
-    #[serde(skip_serializing_if = "Option::is_none")]
     #[validate(range(min = 0, max = 20))]
     pub top_logprobs: Option<u32>,
 
     /// An alternative to sampling with temperature
-    #[serde(skip_serializing_if = "Option::is_none")]
     #[validate(custom(function = "validate_top_p_value"))]
     pub top_p: Option<f32>,
 
     /// Verbosity level for debugging
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub verbosity: Option<i32>,
 
     // =============================================================================
@@ -285,35 +254,28 @@ pub struct ChatCompletionRequest {
     // control model generation behavior in engine-specific ways.
     // =============================================================================
     /// Top-k sampling parameter (-1 to disable)
-    #[serde(skip_serializing_if = "Option::is_none")]
     #[validate(custom(function = "validate_top_k_value"))]
     pub top_k: Option<i32>,
 
     /// Min-p nucleus sampling parameter
-    #[serde(skip_serializing_if = "Option::is_none")]
     #[validate(range(min = 0.0, max = 1.0))]
     pub min_p: Option<f32>,
 
     /// Minimum number of tokens to generate
-    #[serde(skip_serializing_if = "Option::is_none")]
     #[validate(range(min = 1))]
     pub min_tokens: Option<u32>,
 
     /// Repetition penalty for reducing repetitive text
-    #[serde(skip_serializing_if = "Option::is_none")]
     #[validate(range(min = 0.0, max = 2.0))]
     pub repetition_penalty: Option<f32>,
 
     /// Regex constraint for output generation
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub regex: Option<String>,
 
     /// EBNF grammar constraint for structured output
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub ebnf: Option<String>,
 
     /// Specific token IDs to use as stop conditions
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub stop_token_ids: Option<Vec<u32>>,
 
     /// Skip trimming stop tokens from output
@@ -333,11 +295,9 @@ pub struct ChatCompletionRequest {
     pub skip_special_tokens: bool,
 
     /// Path to LoRA adapter(s) for model customization
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub lora_path: Option<String>,
 
     /// Session parameters for continual prompting
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub session_params: Option<HashMap<String, Value>>,
 
     /// Separate reasoning content from final answer (O1-style models)
@@ -349,15 +309,13 @@ pub struct ChatCompletionRequest {
     pub stream_reasoning: bool,
 
     /// Chat template kwargs
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub chat_template_kwargs: Option<HashMap<String, Value>>,
 
     /// Return model hidden states
     #[serde(default)]
     pub return_hidden_states: bool,
 
     /// Random seed for sampling for deterministic outputs
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub sampling_seed: Option<u64>,
 }
 
@@ -702,16 +660,15 @@ impl GenerationRequest for ChatCompletionRequest {
 // Response Types
 // ============================================================================
 
+#[serde_with::skip_serializing_none]
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct ChatCompletionResponse {
     pub id: String,
     pub object: String, // "chat.completion"
     pub created: u64,
     pub model: String,
     pub choices: Vec<ChatChoice>,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub usage: Option<Usage>,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub system_fingerprint: Option<String>,
 }
 
@@ -753,16 +710,15 @@ pub struct ChatChoice {
     pub hidden_states: Option<Vec<f32>>,
 }
 
+#[serde_with::skip_serializing_none]
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct ChatCompletionStreamResponse {
     pub id: String,
     pub object: String, // "chat.completion.chunk"
     pub created: u64,
     pub model: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub system_fingerprint: Option<String>,
     pub choices: Vec<ChatStreamChoice>,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub usage: Option<Usage>,
 }
 

protocols/src/classify.rs

@@ -16,6 +16,7 @@ use super::common::{GenerationRequest, UsageInfo};
 // ============================================================================
 
 /// Classification request - compatible with vLLM's /v1/classify API
+#[serde_with::skip_serializing_none]
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct ClassifyRequest {
     /// ID of the model to use
@@ -28,19 +29,15 @@ pub struct ClassifyRequest {
     pub input: Value,
 
     /// Optional user identifier
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub user: Option<String>,
 
     /// SGLang extension: request id for tracking
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub rid: Option<String>,
 
     /// SGLang extension: request priority
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub priority: Option<i32>,
 
     /// SGLang extension: enable/disable logging of metrics
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub log_metrics: Option<bool>,
 }
 

protocols/src/common.rs

@@ -230,23 +230,20 @@ pub struct StreamOptions {
     pub include_usage: Option<bool>,
 }
 
+#[serde_with::skip_serializing_none]
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct ToolCallDelta {
     pub index: u32,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub id: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
     #[serde(rename = "type")]
     pub tool_type: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub function: Option<FunctionCallDelta>,
 }
 
+#[serde_with::skip_serializing_none]
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct FunctionCallDelta {
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub name: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub arguments: Option<String>,
 }
 
@@ -382,14 +379,13 @@ pub struct Tool {
     pub function: Function,
 }
 
+#[serde_with::skip_serializing_none]
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct Function {
     pub name: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub description: Option<String>,
     pub parameters: Value, // JSON Schema
     /// Whether to enable strict schema adherence (OpenAI structured outputs)
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub strict: Option<bool>,
 }
 
@@ -501,14 +497,13 @@ pub struct CompletionTokensDetails {
 }
 
 /// Usage information (used by rerank and other endpoints)
+#[serde_with::skip_serializing_none]
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct UsageInfo {
     pub prompt_tokens: u32,
     pub completion_tokens: u32,
     pub total_tokens: u32,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub reasoning_tokens: Option<u32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub prompt_tokens_details: Option<PromptTokenUsageInfo>,
 }
 
@@ -559,14 +554,13 @@ pub struct ErrorResponse {
     pub error: ErrorDetail,
 }
 
+#[serde_with::skip_serializing_none]
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct ErrorDetail {
     pub message: String,
     #[serde(rename = "type")]
     pub error_type: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub param: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub code: Option<String>,
 }