Feat/usage improvements (#508)

* i18n: update cache terminology across all languages

- Change 'Cache Read' to 'Cache Hit' in all languages
- Change 'Cache Write' to 'Cache Creation' in all languages
- Update zh: 缓存读取 → 缓存命中, 缓存写入 → 缓存创建
- Update en: Cache Read → Cache Hit, Cache Write → Cache Creation
- Update ja: キャッシュ読取 → キャッシュヒット, キャッシュ書込 → キャッシュ作成

Affected keys: cacheReadTokens, cacheCreationTokens, cacheReadCost,
cacheWriteCost, cacheRead, cacheWrite

* feat(usage): add cache metrics to trend chart

- Add cache creation tokens visualization (orange line)
- Add cache hit tokens visualization (purple line)
- Add gradient definitions for new cache metrics
- Include cache data in hourly aggregation
- Display cache metrics alongside input/output tokens

This provides better visibility into cache usage patterns over time.

* fix(usage): fix timezone handling in datetime picker

- Add timestampToLocalDatetime() to convert Unix timestamp to local datetime
- Add localDatetimeToTimestamp() with validation for incomplete input
- Fix issue where typing hours/minutes would jump to previous day
- Validate datetime format completeness before conversion
- Use local timezone instead of UTC for datetime-local input

This resolves the issue where users couldn't fine-tune time selection
and the input would jump unexpectedly when editing hours or minutes.

* feat(usage): add auto-refresh for usage statistics

- Add 30-second auto-refresh interval for all usage queries
- Disable background refresh to save resources
- Apply to: summary, trends, provider stats, model stats, request logs
- Queries automatically update when tab is active
- Pause refresh when user switches to another tab

This keeps usage data fresh without manual refresh.

* fix(proxy): improve usage logging and cache token parsing

- Log requests even when usage parsing fails (with default values)
- Add detailed debug logging for usage metrics
- Support cache_read_input_tokens field in Codex responses
- Fallback to input_tokens_details.cached_tokens if needed
- Add test case for cached_tokens in input_tokens_details
- Ensure all requests are tracked in database for analytics

This fixes missing request logs when API responses lack usage data
and improves cache token detection across different response formats.

* style(rust): use inline format args in format! macros

- Replace format!("...", var) with format!("...{var}")
- Update universal provider ID formatting
- Update error message formatting
- Update config.toml generation in Codex provider

Fixes clippy::uninlined_format_args warnings.

* feat(proxy): enhance provider router logging

- Add debug logs for failover queue provider count
- Log circuit breaker state for each provider check
- Add logs for missing current provider scenarios
- Log when no current provider is configured
- Use inline format args for better readability

This improves debugging of provider selection and failover behavior.

* feat(database): update model pricing data

- Update Claude models to full version format (e.g. claude-opus-4-5-20251101)
- Add GPT-5.2 series model pricing (10 models)
- Add GPT-5.1 series model pricing (10 models)
- Add GPT-5 series model pricing (12 models)
- Add Gemini 3 series model pricing (2 models)
- Update Gemini 2.5 series model ID format (use dot separator)
- Unify display names by removing thinking level suffixes

* fix(usage): correct Gemini output token calculation

Fix Gemini API output token parsing to use totalTokenCount - promptTokenCount
instead of candidatesTokenCount alone. This ensures thoughtsTokenCount is
included in output statistics.

- Update from_gemini_response to calculate output from total - input
- Update from_gemini_stream_chunks with same logic for consistency
- Fix from_codex_stream_events to use adjusted token calculation
- Add test case for responses with thoughtsTokenCount
- Update existing tests to match new calculation logic

* fix(usage): correct cache token billing and add Codex format auto-detection

- Avoid double-billing cache tokens by subtracting from input before calculation
- Add smart Codex parser that auto-detects OpenAI vs Codex API format
- Extract model name from Codex responses for accurate tracking

* fix(proxy): improve takeover detection with live config check

- Add live config takeover detection for hot-switch decision
- Rebuild takeover when backup is missing or placeholder remains
- Make detect_takeover_in_live_config_for_app public
- Fix is_takeover_active to use actual takeover status

* refactor(usage): simplify model pricing lookup by removing suffix fallback

Replace complex suffix-stripping fallback with direct prefix/suffix cleanup.
Model IDs are now cleaned by removing vendor prefix (before /) and colon
suffix (after :), then matched exactly against pricing table.

* feat(database): add Chinese AI model pricing data

Add pricing for domestic AI models (CNY/1M tokens):
- Doubao-Seed-Code (ByteDance)
- DeepSeek V3/V3.1/V3.2
- Kimi K2/K2-Thinking/K2-Turbo (Moonshot)
- MiniMax M2/M2.1/M2.1-Lightning
- GLM-4.6/4.7 (Zhipu)
- Mimo V2 Flash (Xiaomi)

Also fix test case to use correct model ID and remove invalid currency column.

* refactor(proxy): improve header forwarding with blacklist approach

Change from whitelist to blacklist mode for request header forwarding.
Only skip headers that will be overridden (auth, host, content-length).
This preserves client's original headers and improves compatibility.

* fix(proxy): bypass timeout and retry configs when failover is disabled

When auto_failover_enabled is false, timeout and retry configurations
should not affect normal request flow. This change ensures:

- create_forwarder: passes 0 for all timeout/retry params when failover
  is disabled, effectively bypassing these checks
- streaming_timeout_config: returns 0 for both first_byte_timeout and
  idle_timeout when failover is disabled

This prevents unnecessary timeout errors and retry attempts when users
have explicitly disabled the failover feature.

* fix(proxy): handle zero value input in failover config fields

* refactor(proxy): remove retry logic and add enabled check for failover

* refactor(proxy): distinguish circuit-open from no-provider errors

* Align usage stats to sliding windows

* feat(proxy): add body and header filtering for upstream requests

* feat(proxy): enable transparent passthrough for headers

- Passthrough anthropic-beta header as-is from client
- Passthrough anthropic-version header from client
- Passthrough client IP headers (x-forwarded-for, x-real-ip) by default
- Filter private params (underscore-prefixed fields) from request body
- No database changes required

* feat(proxy): extract session ID from client requests for logging

- Add SessionIdExtractor to parse session ID from Claude/Codex requests
- Support extraction from metadata.user_id, headers, previous_response_id
- Pass session_id through RequestContext to usage logger
- Enable request correlation by session in proxy_request_logs

src-tauri/src/proxy/session.rs

@@ -1,7 +1,15 @@
 //! Proxy Session - 请求会话管理
 //!
 //! 为每个代理请求创建会话上下文，在整个请求生命周期中跟踪状态和元数据。
+//!
+//! ## Session ID 提取
+//!
+//! 支持从客户端请求中提取 Session ID，用于关联同一对话的多个请求：
+//! - Claude: 从 `metadata.user_id` (格式: `user_xxx_session_yyy`) 或 `metadata.session_id` 提取
+//! - Codex: 从 `previous_response_id` 或 headers 中的 `session_id` 提取
+//! - 其他: 生成新的 UUID
 
+use axum::http::HeaderMap;
 use std::time::Instant;
 use uuid::Uuid;
 
@@ -176,6 +184,179 @@ impl ProxySession {
     }
 }
 
+// ============================================================================
+// Session ID 提取器
+// ============================================================================
+
+/// Session ID 来源
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum SessionIdSource {
+    /// 从 metadata.user_id 提取 (Claude)
+    MetadataUserId,
+    /// 从 metadata.session_id 提取
+    MetadataSessionId,
+    /// 从 headers 提取 (Codex)
+    Header,
+    /// 从 previous_response_id 提取 (Codex)
+    PreviousResponseId,
+    /// 新生成
+    Generated,
+}
+
+/// Session ID 提取结果
+#[derive(Debug, Clone)]
+pub struct SessionIdResult {
+    /// 提取或生成的 Session ID
+    pub session_id: String,
+    /// Session ID 来源
+    pub source: SessionIdSource,
+    /// 是否为客户端提供的 ID（非新生成）
+    pub client_provided: bool,
+}
+
+/// 从请求中提取或生成 Session ID
+///
+/// 轻量化实现，仅提取 session_id 用于日志记录，不做复杂的 Session 管理。
+///
+/// ## 提取优先级
+///
+/// ### Claude 请求
+/// 1. `metadata.user_id` (格式: `user_xxx_session_yyy`) → 提取 `yyy` 部分
+/// 2. `metadata.session_id` → 直接使用
+/// 3. 生成新 UUID
+///
+/// ### Codex 请求
+/// 1. Headers: `session_id` 或 `x-session-id`
+/// 2. `metadata.session_id`
+/// 3. `previous_response_id` (对话延续)
+/// 4. 生成新 UUID
+///
+/// ## 示例
+///
+/// ```ignore
+/// let result = extract_session_id(&headers, &body, "claude");
+/// println!("Session ID: {} (from {:?})", result.session_id, result.source);
+/// ```
+pub fn extract_session_id(
+    headers: &HeaderMap,
+    body: &serde_json::Value,
+    client_format: &str,
+) -> SessionIdResult {
+    // Codex 请求特殊处理
+    if client_format == "codex" || client_format == "openai" {
+        if let Some(result) = extract_codex_session(headers, body) {
+            return result;
+        }
+    }
+
+    // Claude 请求：从 metadata 提取
+    if let Some(result) = extract_from_metadata(body) {
+        return result;
+    }
+
+    // 兜底：生成新 Session ID
+    generate_new_session_id()
+}
+
+/// 提取 Codex Session ID
+fn extract_codex_session(headers: &HeaderMap, body: &serde_json::Value) -> Option<SessionIdResult> {
+    // 1. 从 headers 提取
+    for header_name in &["session_id", "x-session-id"] {
+        if let Some(value) = headers.get(*header_name) {
+            if let Ok(session_id) = value.to_str() {
+                // Codex Session ID 通常较长（UUID 格式）
+                if session_id.len() > 20 {
+                    return Some(SessionIdResult {
+                        session_id: format!("codex_{session_id}"),
+                        source: SessionIdSource::Header,
+                        client_provided: true,
+                    });
+                }
+            }
+        }
+    }
+
+    // 2. 从 body.metadata.session_id 提取
+    if let Some(session_id) = body
+        .get("metadata")
+        .and_then(|m| m.get("session_id"))
+        .and_then(|v| v.as_str())
+    {
+        if session_id.len() > 10 {
+            return Some(SessionIdResult {
+                session_id: format!("codex_{session_id}"),
+                source: SessionIdSource::MetadataSessionId,
+                client_provided: true,
+            });
+        }
+    }
+
+    // 3. 从 previous_response_id 提取（对话延续）
+    if let Some(prev_id) = body.get("previous_response_id").and_then(|v| v.as_str()) {
+        if prev_id.len() > 10 {
+            return Some(SessionIdResult {
+                session_id: format!("codex_{prev_id}"),
+                source: SessionIdSource::PreviousResponseId,
+                client_provided: true,
+            });
+        }
+    }
+
+    None
+}
+
+/// 从 metadata 提取 Session ID (Claude)
+fn extract_from_metadata(body: &serde_json::Value) -> Option<SessionIdResult> {
+    let metadata = body.get("metadata")?;
+
+    // 1. 从 metadata.user_id 提取（格式: user_xxx_session_yyy）
+    if let Some(user_id) = metadata.get("user_id").and_then(|v| v.as_str()) {
+        if let Some(session_id) = parse_session_from_user_id(user_id) {
+            return Some(SessionIdResult {
+                session_id,
+                source: SessionIdSource::MetadataUserId,
+                client_provided: true,
+            });
+        }
+    }
+
+    // 2. 直接从 metadata.session_id 提取
+    if let Some(session_id) = metadata.get("session_id").and_then(|v| v.as_str()) {
+        if !session_id.is_empty() {
+            return Some(SessionIdResult {
+                session_id: session_id.to_string(),
+                source: SessionIdSource::MetadataSessionId,
+                client_provided: true,
+            });
+        }
+    }
+
+    None
+}
+
+/// 从 user_id 解析 session_id
+///
+/// 格式: `user_identifier_session_actual_session_id`
+fn parse_session_from_user_id(user_id: &str) -> Option<String> {
+    // 查找 "_session_" 分隔符
+    if let Some(pos) = user_id.find("_session_") {
+        let session_id = &user_id[pos + 9..]; // "_session_" 长度为 9
+        if !session_id.is_empty() {
+            return Some(session_id.to_string());
+        }
+    }
+    None
+}
+
+/// 生成新的 Session ID
+fn generate_new_session_id() -> SessionIdResult {
+    SessionIdResult {
+        session_id: Uuid::new_v4().to_string(),
+        source: SessionIdSource::Generated,
+        client_provided: false,
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -295,4 +476,92 @@ mod tests {
         assert_eq!(ClientFormat::GeminiCli.as_str(), "gemini_cli");
         assert_eq!(ClientFormat::Unknown.as_str(), "unknown");
     }
+
+    // ========== Session ID 提取测试 ==========
+
+    #[test]
+    fn test_extract_session_from_claude_metadata_user_id() {
+        let headers = HeaderMap::new();
+        let body = json!({
+            "model": "claude-3-5-sonnet",
+            "messages": [{"role": "user", "content": "Hello"}],
+            "metadata": {
+                "user_id": "user_john_doe_session_abc123def456"
+            }
+        });
+
+        let result = extract_session_id(&headers, &body, "claude");
+
+        assert_eq!(result.session_id, "abc123def456");
+        assert_eq!(result.source, SessionIdSource::MetadataUserId);
+        assert!(result.client_provided);
+    }
+
+    #[test]
+    fn test_extract_session_from_claude_metadata_session_id() {
+        let headers = HeaderMap::new();
+        let body = json!({
+            "model": "claude-3-5-sonnet",
+            "messages": [{"role": "user", "content": "Hello"}],
+            "metadata": {
+                "session_id": "my-session-123"
+            }
+        });
+
+        let result = extract_session_id(&headers, &body, "claude");
+
+        assert_eq!(result.session_id, "my-session-123");
+        assert_eq!(result.source, SessionIdSource::MetadataSessionId);
+        assert!(result.client_provided);
+    }
+
+    #[test]
+    fn test_extract_session_from_codex_previous_response_id() {
+        let headers = HeaderMap::new();
+        let body = json!({
+            "input": "Write a function",
+            "previous_response_id": "resp_abc123def456789"
+        });
+
+        let result = extract_session_id(&headers, &body, "codex");
+
+        assert_eq!(result.session_id, "codex_resp_abc123def456789");
+        assert_eq!(result.source, SessionIdSource::PreviousResponseId);
+        assert!(result.client_provided);
+    }
+
+    #[test]
+    fn test_extract_session_generates_new_when_not_found() {
+        let headers = HeaderMap::new();
+        let body = json!({
+            "model": "claude-3-5-sonnet",
+            "messages": [{"role": "user", "content": "Hello"}]
+        });
+
+        let result = extract_session_id(&headers, &body, "claude");
+
+        assert!(!result.session_id.is_empty());
+        assert_eq!(result.source, SessionIdSource::Generated);
+        assert!(!result.client_provided);
+    }
+
+    #[test]
+    fn test_parse_session_from_user_id() {
+        assert_eq!(
+            parse_session_from_user_id("user_john_session_abc123"),
+            Some("abc123".to_string())
+        );
+        assert_eq!(
+            parse_session_from_user_id("my_app_session_xyz789"),
+            Some("xyz789".to_string())
+        );
+        // 注意: "_session_" 是分隔符，所以下面的字符串会匹配
+        assert_eq!(
+            parse_session_from_user_id("no_session_marker"),
+            Some("marker".to_string())
+        );
+        // 没有 "_session_" 分隔符的情况
+        assert_eq!(parse_session_from_user_id("user_john_abc123"), None);
+        assert_eq!(parse_session_from_user_id("_session_"), None);
+    }
 }