feat: add cache token tracking and cache-aware cost calculation

Track cache_read_tokens and cache_write_tokens end-to-end: parse from
provider responses (OpenAI, DeepSeek, Grok, Gemini), persist to SQLite,
apply cache-aware pricing from the model registry, and surface in API
responses and the dashboard.

- Add cache fields to ProviderResponse, StreamUsage, RequestLog structs
- Parse cached_tokens (OpenAI/Grok), prompt_cache_hit/miss (DeepSeek),
  cachedContentTokenCount (Gemini) from provider responses
- Send stream_options.include_usage for streaming; capture real usage
  from final SSE chunk in AggregatingStream
- ALTER TABLE migration for cache_read_tokens/cache_write_tokens columns
- Cache-aware cost formula using registry cache_read/cache_write rates
- Update Provider trait calculate_cost signature across all providers
- Add cache_read_tokens/cache_write_tokens to Usage API response
- Dashboard: cache hit rate card, cache columns in pricing and usage
  tables, cache token aggregation in SQL queries
- Remove API debug panel and verbose console logging from api.js
- Bump static asset cache-bust to v5

src/dashboard/models.rs

@@ -84,6 +84,8 @@ pub(super) async fn handle_get_models(
         let mut enabled = true;
         let mut prompt_cost = m_meta.cost.as_ref().map(|c| c.input).unwrap_or(0.0);
         let mut completion_cost = m_meta.cost.as_ref().map(|c| c.output).unwrap_or(0.0);
+        let cache_read_cost = m_meta.cost.as_ref().and_then(|c| c.cache_read);
+        let cache_write_cost = m_meta.cost.as_ref().and_then(|c| c.cache_write);
         let mut mapping = None::<String>;
 
         if let Some(row) = db_models.get(m_key) {
@@ -105,6 +107,8 @@ pub(super) async fn handle_get_models(
             "enabled": enabled,
             "prompt_cost": prompt_cost,
             "completion_cost": completion_cost,
+            "cache_read_cost": cache_read_cost,
+            "cache_write_cost": cache_write_cost,
             "mapping": mapping,
             "context_limit": m_meta.limit.as_ref().map(|l| l.context).unwrap_or(0),
             "output_limit": m_meta.limit.as_ref().map(|l| l.output).unwrap_or(0),

src/dashboard/usage.rs

@@ -16,7 +16,9 @@ pub(super) async fn handle_usage_summary(State(state): State<DashboardState>) ->
             COUNT(*) as total_requests,
             COALESCE(SUM(total_tokens), 0) as total_tokens,
             COALESCE(SUM(cost), 0.0) as total_cost,
-            COUNT(DISTINCT client_id) as active_clients
+            COUNT(DISTINCT client_id) as active_clients,
+            COALESCE(SUM(cache_read_tokens), 0) as total_cache_read,
+            COALESCE(SUM(cache_write_tokens), 0) as total_cache_write
         FROM llm_requests
         "#,
     )
@@ -64,6 +66,8 @@ pub(super) async fn handle_usage_summary(State(state): State<DashboardState>) ->
             let total_tokens: i64 = t.get("total_tokens");
             let total_cost: f64 = t.get("total_cost");
             let active_clients: i64 = t.get("active_clients");
+            let total_cache_read: i64 = t.get("total_cache_read");
+            let total_cache_write: i64 = t.get("total_cache_write");
 
             let today_requests: i64 = d.get("today_requests");
             let today_cost: f64 = d.get("today_cost");
@@ -87,6 +91,8 @@ pub(super) async fn handle_usage_summary(State(state): State<DashboardState>) ->
                 "today_cost": today_cost,
                 "error_rate": error_rate,
                 "avg_response_time": avg_response_time,
+                "total_cache_read_tokens": total_cache_read,
+                "total_cache_write_tokens": total_cache_write,
             })))
         }
         _ => Json(ApiResponse::error("Failed to fetch usage statistics".to_string())),
@@ -208,7 +214,9 @@ pub(super) async fn handle_providers_usage(
             provider,
             COUNT(*) as requests,
             COALESCE(SUM(total_tokens), 0) as tokens,
-            COALESCE(SUM(cost), 0.0) as cost
+            COALESCE(SUM(cost), 0.0) as cost,
+            COALESCE(SUM(cache_read_tokens), 0) as cache_read,
+            COALESCE(SUM(cache_write_tokens), 0) as cache_write
         FROM llm_requests
         GROUP BY provider
         ORDER BY requests DESC
@@ -226,12 +234,16 @@ pub(super) async fn handle_providers_usage(
                 let requests: i64 = row.get("requests");
                 let tokens: i64 = row.get("tokens");
                 let cost: f64 = row.get("cost");
+                let cache_read: i64 = row.get("cache_read");
+                let cache_write: i64 = row.get("cache_write");
 
                 provider_usage.push(serde_json::json!({
                     "provider": provider,
                     "requests": requests,
                     "tokens": tokens,
                     "cost": cost,
+                    "cache_read_tokens": cache_read,
+                    "cache_write_tokens": cache_write,
                 }));
             }
 
@@ -256,7 +268,9 @@ pub(super) async fn handle_detailed_usage(State(state): State<DashboardState>) -
             model,
             COUNT(*) as requests,
             COALESCE(SUM(total_tokens), 0) as tokens,
-            COALESCE(SUM(cost), 0.0) as cost
+            COALESCE(SUM(cost), 0.0) as cost,
+            COALESCE(SUM(cache_read_tokens), 0) as cache_read,
+            COALESCE(SUM(cache_write_tokens), 0) as cache_write
         FROM llm_requests
         GROUP BY date, client_id, provider, model
         ORDER BY date DESC
@@ -279,6 +293,8 @@ pub(super) async fn handle_detailed_usage(State(state): State<DashboardState>) -
                         "requests": row.get::<i64, _>("requests"),
                         "tokens": row.get::<i64, _>("tokens"),
                         "cost": row.get::<f64, _>("cost"),
+                        "cache_read_tokens": row.get::<i64, _>("cache_read"),
+                        "cache_write_tokens": row.get::<i64, _>("cache_write"),
                     })
                 })
                 .collect();

src/database/mod.rs

@@ -135,6 +135,14 @@ async fn run_migrations(pool: &DbPool) -> Result<()> {
         .execute(pool)
         .await;
 
+    // Add cache token columns if they don't exist (migration for existing DBs)
+    let _ = sqlx::query("ALTER TABLE llm_requests ADD COLUMN cache_read_tokens INTEGER DEFAULT 0")
+        .execute(pool)
+        .await;
+    let _ = sqlx::query("ALTER TABLE llm_requests ADD COLUMN cache_write_tokens INTEGER DEFAULT 0")
+        .execute(pool)
+        .await;
+
     // Insert default admin user if none exists (default password: admin)
     let user_count: (i64,) = sqlx::query_as("SELECT COUNT(*) FROM users").fetch_one(pool).await?;
 

src/logging/mod.rs

@@ -16,6 +16,8 @@ pub struct RequestLog {
     pub prompt_tokens: u32,
     pub completion_tokens: u32,
     pub total_tokens: u32,
+    pub cache_read_tokens: u32,
+    pub cache_write_tokens: u32,
     pub cost: f64,
     pub has_images: bool,
     pub status: String, // "success", "error"
@@ -75,8 +77,8 @@ impl RequestLogger {
         sqlx::query(
             r#"
             INSERT INTO llm_requests 
-            (timestamp, client_id, provider, model, prompt_tokens, completion_tokens, total_tokens, cost, has_images, status, error_message, duration_ms, request_body, response_body)
-            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            (timestamp, client_id, provider, model, prompt_tokens, completion_tokens, total_tokens, cache_read_tokens, cache_write_tokens, cost, has_images, status, error_message, duration_ms, request_body, response_body)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
             "#,
         )
         .bind(log.timestamp)
@@ -86,6 +88,8 @@ impl RequestLogger {
         .bind(log.prompt_tokens as i64)
         .bind(log.completion_tokens as i64)
         .bind(log.total_tokens as i64)
+        .bind(log.cache_read_tokens as i64)
+        .bind(log.cache_write_tokens as i64)
         .bind(log.cost)
         .bind(log.has_images)
         .bind(log.status)

src/models/mod.rs

@@ -152,6 +152,10 @@ pub struct Usage {
     pub prompt_tokens: u32,
     pub completion_tokens: u32,
     pub total_tokens: u32,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub cache_read_tokens: Option<u32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub cache_write_tokens: Option<u32>,
 }
 
 // ========== Streaming Response Structs ==========

src/providers/deepseek.rs

@@ -90,12 +90,16 @@ impl super::Provider for DeepSeekProvider {
         model: &str,
         prompt_tokens: u32,
         completion_tokens: u32,
+        cache_read_tokens: u32,
+        cache_write_tokens: u32,
         registry: &crate::models::registry::ModelRegistry,
     ) -> f64 {
         helpers::calculate_cost_with_registry(
             model,
             prompt_tokens,
             completion_tokens,
+            cache_read_tokens,
+            cache_write_tokens,
             registry,
             &self.pricing,
             0.14,

src/providers/gemini.rs

@@ -119,6 +119,8 @@ struct GeminiUsageMetadata {
     candidates_token_count: u32,
     #[serde(default)]
     total_token_count: u32,
+    #[serde(default)]
+    cached_content_token_count: u32,
 }
 
 #[derive(Debug, Deserialize)]
@@ -454,6 +456,11 @@ impl super::Provider for GeminiProvider {
             .as_ref()
             .map(|u| u.total_token_count)
             .unwrap_or(0);
+        let cache_read_tokens = gemini_response
+            .usage_metadata
+            .as_ref()
+            .map(|u| u.cached_content_token_count)
+            .unwrap_or(0);
 
         Ok(ProviderResponse {
             content,
@@ -462,6 +469,8 @@ impl super::Provider for GeminiProvider {
             prompt_tokens,
             completion_tokens,
             total_tokens,
+            cache_read_tokens,
+            cache_write_tokens: 0, // Gemini doesn't report cache writes separately
             model,
         })
     }
@@ -475,12 +484,16 @@ impl super::Provider for GeminiProvider {
         model: &str,
         prompt_tokens: u32,
         completion_tokens: u32,
+        cache_read_tokens: u32,
+        cache_write_tokens: u32,
         registry: &crate::models::registry::ModelRegistry,
     ) -> f64 {
         super::helpers::calculate_cost_with_registry(
             model,
             prompt_tokens,
             completion_tokens,
+            cache_read_tokens,
+            cache_write_tokens,
             registry,
             &self.pricing,
             0.075,
@@ -537,6 +550,17 @@ impl super::Provider for GeminiProvider {
                         let gemini_response: GeminiResponse = serde_json::from_str(&msg.data)
                             .map_err(|e| AppError::ProviderError(format!("Failed to parse stream chunk: {}", e)))?;
 
+                        // Extract usage from usageMetadata if present (reported on every/last chunk)
+                        let stream_usage = gemini_response.usage_metadata.as_ref().map(|u| {
+                            super::StreamUsage {
+                                prompt_tokens: u.prompt_token_count,
+                                completion_tokens: u.candidates_token_count,
+                                total_tokens: u.total_token_count,
+                                cache_read_tokens: u.cached_content_token_count,
+                                cache_write_tokens: 0,
+                            }
+                        });
+
                         if let Some(candidate) = gemini_response.candidates.first() {
                             let content = candidate
                                 .content
@@ -561,6 +585,7 @@ impl super::Provider for GeminiProvider {
                                 finish_reason,
                                 tool_calls,
                                 model: model.clone(),
+                                usage: stream_usage,
                             };
                         }
                     }

src/providers/grok.rs

@@ -86,12 +86,16 @@ impl super::Provider for GrokProvider {
         model: &str,
         prompt_tokens: u32,
         completion_tokens: u32,
+        cache_read_tokens: u32,
+        cache_write_tokens: u32,
         registry: &crate::models::registry::ModelRegistry,
     ) -> f64 {
         helpers::calculate_cost_with_registry(
             model,
             prompt_tokens,
             completion_tokens,
+            cache_read_tokens,
+            cache_write_tokens,
             registry,
             &self.pricing,
             5.0,

src/providers/helpers.rs

@@ -1,4 +1,4 @@
-use super::{ProviderResponse, ProviderStreamChunk};
+use super::{ProviderResponse, ProviderStreamChunk, StreamUsage};
 use crate::errors::AppError;
 use crate::models::{ContentPart, ToolCall, ToolCallDelta, UnifiedMessage, UnifiedRequest};
 use futures::stream::{BoxStream, StreamExt};
@@ -156,6 +156,8 @@ pub async fn messages_to_openai_json_text_only(
 
 /// Build an OpenAI-compatible request body from a UnifiedRequest and pre-converted messages.
 /// Includes tools and tool_choice when present.
+/// When streaming, adds `stream_options.include_usage: true` so providers report
+/// token counts in the final SSE chunk.
 pub fn build_openai_body(
     request: &UnifiedRequest,
     messages_json: Vec<serde_json::Value>,
@@ -167,6 +169,10 @@ pub fn build_openai_body(
         "stream": stream,
     });
 
+    if stream {
+        body["stream_options"] = serde_json::json!({ "include_usage": true });
+    }
+
     if let Some(temp) = request.temperature {
         body["temperature"] = serde_json::json!(temp);
     }
@@ -185,6 +191,9 @@ pub fn build_openai_body(
 
 /// Parse an OpenAI-compatible chat completion response JSON into a ProviderResponse.
 /// Extracts tool_calls from the message when present.
+/// Extracts cache token counts from:
+/// - OpenAI/Grok: `usage.prompt_tokens_details.cached_tokens`
+/// - DeepSeek: `usage.prompt_cache_hit_tokens` / `usage.prompt_cache_miss_tokens`
 pub fn parse_openai_response(resp_json: &Value, model: String) -> Result<ProviderResponse, AppError> {
     let choice = resp_json["choices"]
         .get(0)
@@ -204,6 +213,17 @@ pub fn parse_openai_response(resp_json: &Value, model: String) -> Result<Provide
     let completion_tokens = usage["completion_tokens"].as_u64().unwrap_or(0) as u32;
     let total_tokens = usage["total_tokens"].as_u64().unwrap_or(0) as u32;
 
+    // Extract cache tokens — try OpenAI/Grok format first, then DeepSeek format
+    let cache_read_tokens = usage["prompt_tokens_details"]["cached_tokens"]
+        .as_u64()
+        // DeepSeek uses a different field name
+        .or_else(|| usage["prompt_cache_hit_tokens"].as_u64())
+        .unwrap_or(0) as u32;
+
+    // DeepSeek reports cache_write as prompt_cache_miss_tokens (tokens written to cache for future use).
+    // OpenAI doesn't report cache_write in this location, but may in the future.
+    let cache_write_tokens = usage["prompt_cache_miss_tokens"].as_u64().unwrap_or(0) as u32;
+
     Ok(ProviderResponse {
         content,
         reasoning_content,
@@ -211,6 +231,8 @@ pub fn parse_openai_response(resp_json: &Value, model: String) -> Result<Provide
         prompt_tokens,
         completion_tokens,
         total_tokens,
+        cache_read_tokens,
+        cache_write_tokens,
         model,
     })
 }
@@ -220,6 +242,9 @@ pub fn parse_openai_response(resp_json: &Value, model: String) -> Result<Provide
 /// The optional `reasoning_field` allows overriding the field name for
 /// reasoning content (e.g., "thought" for Ollama).
 /// Parses tool_calls deltas from streaming chunks when present.
+/// When `stream_options.include_usage: true` was sent, the provider sends a
+/// final chunk with `usage` data — this is parsed into `StreamUsage` and
+/// attached to the yielded `ProviderStreamChunk`.
 pub fn create_openai_stream(
     es: reqwest_eventsource::EventSource,
     model: String,
@@ -239,6 +264,34 @@ pub fn create_openai_stream(
                     let chunk: Value = serde_json::from_str(&msg.data)
                         .map_err(|e| AppError::ProviderError(format!("Failed to parse stream chunk: {}", e)))?;
 
+                    // Parse usage from the final chunk (sent when stream_options.include_usage is true).
+                    // This chunk may have an empty `choices` array.
+                    let stream_usage = chunk.get("usage").and_then(|u| {
+                        if u.is_null() {
+                            return None;
+                        }
+                        let prompt_tokens = u["prompt_tokens"].as_u64().unwrap_or(0) as u32;
+                        let completion_tokens = u["completion_tokens"].as_u64().unwrap_or(0) as u32;
+                        let total_tokens = u["total_tokens"].as_u64().unwrap_or(0) as u32;
+
+                        let cache_read_tokens = u["prompt_tokens_details"]["cached_tokens"]
+                            .as_u64()
+                            .or_else(|| u["prompt_cache_hit_tokens"].as_u64())
+                            .unwrap_or(0) as u32;
+
+                        let cache_write_tokens = u["prompt_cache_miss_tokens"]
+                            .as_u64()
+                            .unwrap_or(0) as u32;
+
+                        Some(StreamUsage {
+                            prompt_tokens,
+                            completion_tokens,
+                            total_tokens,
+                            cache_read_tokens,
+                            cache_write_tokens,
+                        })
+                    });
+
                     if let Some(choice) = chunk["choices"].get(0) {
                         let delta = &choice["delta"];
                         let content = delta["content"].as_str().unwrap_or_default().to_string();
@@ -259,6 +312,18 @@ pub fn create_openai_stream(
                             finish_reason,
                             tool_calls,
                             model: model.clone(),
+                            usage: stream_usage,
+                        };
+                    } else if stream_usage.is_some() {
+                        // Final usage-only chunk (empty choices array) — yield it so
+                        // AggregatingStream can capture the real token counts.
+                        yield ProviderStreamChunk {
+                            content: String::new(),
+                            reasoning_content: None,
+                            finish_reason: None,
+                            tool_calls: None,
+                            model: model.clone(),
+                            usage: stream_usage,
                         };
                     }
                 }
@@ -274,10 +339,20 @@ pub fn create_openai_stream(
 }
 
 /// Calculate cost using the model registry first, then falling back to provider pricing config.
+///
+/// When the registry provides `cache_read` / `cache_write` rates, the formula is:
+///   (prompt_tokens - cache_read_tokens) * input_rate
+///   + cache_read_tokens * cache_read_rate
+///   + cache_write_tokens * cache_write_rate   (if applicable)
+///   + completion_tokens * output_rate
+///
+/// All rates are per-token (the registry stores per-million-token rates).
 pub fn calculate_cost_with_registry(
     model: &str,
     prompt_tokens: u32,
     completion_tokens: u32,
+    cache_read_tokens: u32,
+    cache_write_tokens: u32,
     registry: &crate::models::registry::ModelRegistry,
     pricing: &[crate::config::ModelPricing],
     default_prompt_rate: f64,
@@ -286,10 +361,25 @@ pub fn calculate_cost_with_registry(
     if let Some(metadata) = registry.find_model(model)
         && let Some(cost) = &metadata.cost
     {
-        return (prompt_tokens as f64 * cost.input / 1_000_000.0)
+        let non_cached_prompt = prompt_tokens.saturating_sub(cache_read_tokens);
+        let mut total = (non_cached_prompt as f64 * cost.input / 1_000_000.0)
             + (completion_tokens as f64 * cost.output / 1_000_000.0);
+
+        if let Some(cache_read_rate) = cost.cache_read {
+            total += cache_read_tokens as f64 * cache_read_rate / 1_000_000.0;
+        } else {
+            // No cache_read rate — charge cached tokens at full input rate
+            total += cache_read_tokens as f64 * cost.input / 1_000_000.0;
+        }
+
+        if let Some(cache_write_rate) = cost.cache_write {
+            total += cache_write_tokens as f64 * cache_write_rate / 1_000_000.0;
+        }
+
+        return total;
     }
 
+    // Fallback: no registry entry — use provider pricing config (no cache awareness)
     let (prompt_rate, completion_rate) = pricing
         .iter()
         .find(|p| model.contains(&p.model))

src/providers/mod.rs

@@ -37,12 +37,16 @@ pub trait Provider: Send + Sync {
     /// Estimate token count for a request (for cost calculation)
     fn estimate_tokens(&self, request: &UnifiedRequest) -> Result<u32>;
 
-    /// Calculate cost based on token usage and model using the registry
+    /// Calculate cost based on token usage and model using the registry.
+    /// `cache_read_tokens` / `cache_write_tokens` allow cache-aware pricing
+    /// when the registry provides `cache_read` / `cache_write` rates.
     fn calculate_cost(
         &self,
         model: &str,
         prompt_tokens: u32,
         completion_tokens: u32,
+        cache_read_tokens: u32,
+        cache_write_tokens: u32,
         registry: &crate::models::registry::ModelRegistry,
     ) -> f64;
 }
@@ -54,9 +58,21 @@ pub struct ProviderResponse {
     pub prompt_tokens: u32,
     pub completion_tokens: u32,
     pub total_tokens: u32,
+    pub cache_read_tokens: u32,
+    pub cache_write_tokens: u32,
     pub model: String,
 }
 
+/// Usage data from the final streaming chunk (when providers report real token counts).
+#[derive(Debug, Clone, Default)]
+pub struct StreamUsage {
+    pub prompt_tokens: u32,
+    pub completion_tokens: u32,
+    pub total_tokens: u32,
+    pub cache_read_tokens: u32,
+    pub cache_write_tokens: u32,
+}
+
 #[derive(Debug, Clone)]
 pub struct ProviderStreamChunk {
     pub content: String,
@@ -64,6 +80,8 @@ pub struct ProviderStreamChunk {
     pub finish_reason: Option<String>,
     pub tool_calls: Option<Vec<crate::models::ToolCallDelta>>,
     pub model: String,
+    /// Populated only on the final chunk when providers report usage (e.g. stream_options.include_usage).
+    pub usage: Option<StreamUsage>,
 }
 
 use tokio::sync::RwLock;
@@ -299,6 +317,8 @@ pub mod placeholder {
             _model: &str,
             _prompt_tokens: u32,
             _completion_tokens: u32,
+            _cache_read_tokens: u32,
+            _cache_write_tokens: u32,
             _registry: &crate::models::registry::ModelRegistry,
         ) -> f64 {
             0.0

src/providers/ollama.rs

@@ -95,12 +95,16 @@ impl super::Provider for OllamaProvider {
         model: &str,
         prompt_tokens: u32,
         completion_tokens: u32,
+        cache_read_tokens: u32,
+        cache_write_tokens: u32,
         registry: &crate::models::registry::ModelRegistry,
     ) -> f64 {
         helpers::calculate_cost_with_registry(
             model,
             prompt_tokens,
             completion_tokens,
+            cache_read_tokens,
+            cache_write_tokens,
             registry,
             &self.pricing,
             0.0,

src/providers/openai.rs

@@ -86,12 +86,16 @@ impl super::Provider for OpenAIProvider {
         model: &str,
         prompt_tokens: u32,
         completion_tokens: u32,
+        cache_read_tokens: u32,
+        cache_write_tokens: u32,
         registry: &crate::models::registry::ModelRegistry,
     ) -> f64 {
         helpers::calculate_cost_with_registry(
             model,
             prompt_tokens,
             completion_tokens,
+            cache_read_tokens,
+            cache_write_tokens,
             registry,
             &self.pricing,
             0.15,

src/server/mod.rs

@@ -97,18 +97,21 @@ async fn get_model_cost(
     model: &str,
     prompt_tokens: u32,
     completion_tokens: u32,
+    cache_read_tokens: u32,
+    cache_write_tokens: u32,
     provider: &Arc<dyn crate::providers::Provider>,
     state: &AppState,
 ) -> f64 {
     // Check in-memory cache for cost overrides (no SQLite hit)
     if let Some(cached) = state.model_config_cache.get(model).await {
         if let (Some(p), Some(c)) = (cached.prompt_cost_per_m, cached.completion_cost_per_m) {
+            // Manual overrides don't have cache-specific rates, so use simple formula
             return (prompt_tokens as f64 * p / 1_000_000.0) + (completion_tokens as f64 * c / 1_000_000.0);
         }
     }
 
-    // Fallback to provider's registry-based calculation
-    provider.calculate_cost(model, prompt_tokens, completion_tokens, &state.model_registry)
+    // Fallback to provider's registry-based calculation (cache-aware)
+    provider.calculate_cost(model, prompt_tokens, completion_tokens, cache_read_tokens, cache_write_tokens, &state.model_registry)
 }
 
 async fn chat_completions(
@@ -281,6 +284,8 @@ async fn chat_completions(
                     &response.model,
                     response.prompt_tokens,
                     response.completion_tokens,
+                    response.cache_read_tokens,
+                    response.cache_write_tokens,
                     &provider,
                     &state,
                 )
@@ -294,6 +299,8 @@ async fn chat_completions(
                     prompt_tokens: response.prompt_tokens,
                     completion_tokens: response.completion_tokens,
                     total_tokens: response.total_tokens,
+                    cache_read_tokens: response.cache_read_tokens,
+                    cache_write_tokens: response.cache_write_tokens,
                     cost,
                     has_images,
                     status: "success".to_string(),
@@ -340,6 +347,8 @@ async fn chat_completions(
                         prompt_tokens: response.prompt_tokens,
                         completion_tokens: response.completion_tokens,
                         total_tokens: response.total_tokens,
+                        cache_read_tokens: if response.cache_read_tokens > 0 { Some(response.cache_read_tokens) } else { None },
+                        cache_write_tokens: if response.cache_write_tokens > 0 { Some(response.cache_write_tokens) } else { None },
                     }),
                 };
 
@@ -368,6 +377,8 @@ async fn chat_completions(
                     prompt_tokens: 0,
                     completion_tokens: 0,
                     total_tokens: 0,
+                    cache_read_tokens: 0,
+                    cache_write_tokens: 0,
                     cost: 0.0,
                     has_images: false,
                     status: "error".to_string(),

src/utils/streaming.rs

@@ -2,7 +2,7 @@ use crate::client::ClientManager;
 use crate::errors::AppError;
 use crate::logging::{RequestLog, RequestLogger};
 use crate::models::ToolCall;
-use crate::providers::{Provider, ProviderStreamChunk};
+use crate::providers::{Provider, ProviderStreamChunk, StreamUsage};
 use crate::state::ModelConfigCache;
 use crate::utils::tokens::estimate_completion_tokens;
 use futures::stream::Stream;
@@ -33,6 +33,8 @@ pub struct AggregatingStream<S> {
     accumulated_content: String,
     accumulated_reasoning: String,
     accumulated_tool_calls: Vec<ToolCall>,
+    /// Real usage data from the provider's final stream chunk (when available).
+    real_usage: Option<StreamUsage>,
     logger: Arc<RequestLogger>,
     client_manager: Arc<ClientManager>,
     model_registry: Arc<crate::models::registry::ModelRegistry>,
@@ -56,6 +58,7 @@ where
             accumulated_content: String::new(),
             accumulated_reasoning: String::new(),
             accumulated_tool_calls: Vec::new(),
+            real_usage: None,
             logger: config.logger,
             client_manager: config.client_manager,
             model_registry: config.model_registry,
@@ -78,33 +81,68 @@ where
         let logger = self.logger.clone();
         let client_manager = self.client_manager.clone();
         let provider = self.provider.clone();
-        let prompt_tokens = self.prompt_tokens;
+        let estimated_prompt_tokens = self.prompt_tokens;
         let has_images = self.has_images;
         let registry = self.model_registry.clone();
         let config_cache = self.model_config_cache.clone();
+        let real_usage = self.real_usage.take();
 
         // Estimate completion tokens (including reasoning if present)
-        let content_tokens = estimate_completion_tokens(&self.accumulated_content, &model);
-        let reasoning_tokens = if !self.accumulated_reasoning.is_empty() {
+        let estimated_content_tokens = estimate_completion_tokens(&self.accumulated_content, &model);
+        let estimated_reasoning_tokens = if !self.accumulated_reasoning.is_empty() {
             estimate_completion_tokens(&self.accumulated_reasoning, &model)
         } else {
             0
         };
 
-        let completion_tokens = content_tokens + reasoning_tokens;
-        let total_tokens = prompt_tokens + completion_tokens;
+        let estimated_completion = estimated_content_tokens + estimated_reasoning_tokens;
 
         // Spawn a background task to log the completion
         tokio::spawn(async move {
+            // Use real usage from the provider when available, otherwise fall back to estimates
+            let (prompt_tokens, completion_tokens, total_tokens, cache_read_tokens, cache_write_tokens) =
+                if let Some(usage) = &real_usage {
+                    (
+                        usage.prompt_tokens,
+                        usage.completion_tokens,
+                        usage.total_tokens,
+                        usage.cache_read_tokens,
+                        usage.cache_write_tokens,
+                    )
+                } else {
+                    (
+                        estimated_prompt_tokens,
+                        estimated_completion,
+                        estimated_prompt_tokens + estimated_completion,
+                        0u32,
+                        0u32,
+                    )
+                };
+
             // Check in-memory cache for cost overrides (no SQLite hit)
             let cost = if let Some(cached) = config_cache.get(&model).await {
                 if let (Some(p), Some(c)) = (cached.prompt_cost_per_m, cached.completion_cost_per_m) {
+                    // Cost override doesn't have cache-aware pricing, use simple formula
                     (prompt_tokens as f64 * p / 1_000_000.0) + (completion_tokens as f64 * c / 1_000_000.0)
                 } else {
-                    provider.calculate_cost(&model, prompt_tokens, completion_tokens, &registry)
+                    provider.calculate_cost(
+                        &model,
+                        prompt_tokens,
+                        completion_tokens,
+                        cache_read_tokens,
+                        cache_write_tokens,
+                        &registry,
+                    )
                 }
             } else {
-                provider.calculate_cost(&model, prompt_tokens, completion_tokens, &registry)
+                provider.calculate_cost(
+                    &model,
+                    prompt_tokens,
+                    completion_tokens,
+                    cache_read_tokens,
+                    cache_write_tokens,
+                    &registry,
+                )
             };
 
             // Log to database
@@ -116,6 +154,8 @@ where
                 prompt_tokens,
                 completion_tokens,
                 total_tokens,
+                cache_read_tokens,
+                cache_write_tokens,
                 cost,
                 has_images,
                 status: "success".to_string(),
@@ -146,6 +186,10 @@ where
                 if let Some(reasoning) = &chunk.reasoning_content {
                     self.accumulated_reasoning.push_str(reasoning);
                 }
+                // Capture real usage from the provider when present (typically on the final chunk)
+                if let Some(usage) = &chunk.usage {
+                    self.real_usage = Some(usage.clone());
+                }
                 // Accumulate tool call deltas into complete tool calls
                 if let Some(deltas) = &chunk.tool_calls {
                     for delta in deltas {
@@ -230,7 +274,7 @@ mod tests {
         fn estimate_tokens(&self, _req: &crate::models::UnifiedRequest) -> Result<u32> {
             Ok(10)
         }
-        fn calculate_cost(&self, _model: &str, _p: u32, _c: u32, _r: &crate::models::registry::ModelRegistry) -> f64 {
+        fn calculate_cost(&self, _model: &str, _p: u32, _c: u32, _cr: u32, _cw: u32, _r: &crate::models::registry::ModelRegistry) -> f64 {
             0.05
         }
     }
@@ -244,6 +288,7 @@ mod tests {
                 finish_reason: None,
                 tool_calls: None,
                 model: "test".to_string(),
+                usage: None,
             }),
             Ok(ProviderStreamChunk {
                 content: " World".to_string(),
@@ -251,6 +296,7 @@ mod tests {
                 finish_reason: Some("stop".to_string()),
                 tool_calls: None,
                 model: "test".to_string(),
+                usage: None,
             }),
         ];
         let inner_stream = stream::iter(chunks);