refactor: 拆分 gateway 单体为独立 crate，新增 systemd 部署方案

将 gateway 内部的 model-fetch、provider-transport、scheduler-core、
usage-runtime、video-tasks-core 模块提取为独立 crate；重构 gateway
内部模块结构（state/router/cache/data/query 等）；移除大量遗留模块
文件；新增 systemd 二进制部署骨架及相关文档；更新前端 usage 相关
API 和组件。

crates/aether-billing/Cargo.toml

@@ -7,6 +7,10 @@ repository.workspace = true
 description = "Shared billing domain core for Aether Rust migration"
 
 [dependencies]
+aether-data.workspace = true
+aether-usage-runtime.workspace = true
+async-trait.workspace = true
 serde.workspace = true
 serde_json.workspace = true
 thiserror.workspace = true
+tokio.workspace = true

crates/aether-billing/src/event_enrichment.rs

@@ -0,0 +1,223 @@
+use aether_data::repository::billing::StoredBillingModelContext;
+use aether_data::DataLayerError;
+use aether_usage_runtime::{UsageEvent, UsageEventType};
+use async_trait::async_trait;
+use serde_json::{Map, Value};
+
+use crate::{BillingModelPricingSnapshot, BillingService, BillingUsageInput};
+
+#[async_trait]
+pub trait BillingModelContextLookup: Send + Sync {
+    async fn find_billing_model_context(
+        &self,
+        provider_id: &str,
+        provider_api_key_id: Option<&str>,
+        global_model_name: &str,
+    ) -> Result<Option<StoredBillingModelContext>, DataLayerError>;
+}
+
+pub async fn enrich_usage_event_with_billing(
+    data: &dyn BillingModelContextLookup,
+    event: &mut UsageEvent,
+) -> Result<(), DataLayerError> {
+    if !matches!(event.event_type, UsageEventType::Completed) {
+        event.data.total_cost_usd = Some(0.0);
+        event.data.actual_total_cost_usd = Some(0.0);
+        return Ok(());
+    }
+
+    let Some(provider_id) = event
+        .data
+        .provider_id
+        .as_deref()
+        .map(str::trim)
+        .filter(|value| !value.is_empty())
+    else {
+        return Ok(());
+    };
+    let model_name = event.data.model.trim();
+    if model_name.is_empty() {
+        return Ok(());
+    }
+
+    let Some(context) = data
+        .find_billing_model_context(
+            provider_id,
+            event.data.provider_api_key_id.as_deref(),
+            model_name,
+        )
+        .await?
+    else {
+        return Ok(());
+    };
+
+    let pricing = map_pricing_context(context);
+    let input = BillingUsageInput {
+        task_type: event
+            .data
+            .request_type
+            .clone()
+            .unwrap_or_else(|| "chat".to_string()),
+        api_format: event
+            .data
+            .endpoint_api_format
+            .clone()
+            .or_else(|| event.data.api_format.clone()),
+        request_count: if event.data.status_code.unwrap_or_default() >= 400
+            || event.data.error_message.is_some()
+        {
+            0
+        } else {
+            1
+        },
+        input_tokens: event.data.input_tokens.unwrap_or_default() as i64,
+        output_tokens: event.data.output_tokens.unwrap_or_default() as i64,
+        cache_creation_tokens: event.data.cache_creation_input_tokens.unwrap_or_default() as i64,
+        cache_read_tokens: event.data.cache_read_input_tokens.unwrap_or_default() as i64,
+        cache_ttl_minutes: pricing.provider_api_key_cache_ttl_minutes,
+    };
+
+    let computation = BillingService::new()
+        .calculate(&pricing, &input)
+        .map_err(|err| {
+            DataLayerError::UnexpectedValue(format!("billing calculation failed: {err}"))
+        })?;
+    event.data.total_cost_usd = Some(computation.cost_result.cost);
+    event.data.actual_total_cost_usd = Some(computation.actual_total_cost);
+    merge_billing_snapshot_metadata(
+        &mut event.data.request_metadata,
+        &computation.cost_result.snapshot,
+        computation.rate_multiplier,
+        computation.is_free_tier,
+    )?;
+    Ok(())
+}
+
+fn map_pricing_context(context: StoredBillingModelContext) -> BillingModelPricingSnapshot {
+    BillingModelPricingSnapshot {
+        provider_id: context.provider_id,
+        provider_billing_type: context.provider_billing_type,
+        provider_api_key_id: context.provider_api_key_id,
+        provider_api_key_rate_multipliers: context.provider_api_key_rate_multipliers,
+        provider_api_key_cache_ttl_minutes: context.provider_api_key_cache_ttl_minutes,
+        global_model_id: context.global_model_id,
+        global_model_name: context.global_model_name,
+        global_model_config: context.global_model_config,
+        default_price_per_request: context.default_price_per_request,
+        default_tiered_pricing: context.default_tiered_pricing,
+        model_id: context.model_id,
+        model_provider_model_name: context.model_provider_model_name,
+        model_config: context.model_config,
+        model_price_per_request: context.model_price_per_request,
+        model_tiered_pricing: context.model_tiered_pricing,
+    }
+}
+
+fn merge_billing_snapshot_metadata(
+    request_metadata: &mut Option<Value>,
+    snapshot: &crate::BillingSnapshot,
+    rate_multiplier: f64,
+    is_free_tier: bool,
+) -> Result<(), DataLayerError> {
+    let snapshot = serde_json::to_value(snapshot).map_err(|err| {
+        DataLayerError::UnexpectedValue(format!("failed to serialize billing snapshot: {err}"))
+    })?;
+
+    let mut metadata = match request_metadata.take() {
+        Some(Value::Object(object)) => object,
+        _ => Map::new(),
+    };
+    metadata.insert("billing_snapshot".to_string(), snapshot);
+    metadata.insert("rate_multiplier".to_string(), Value::from(rate_multiplier));
+    metadata.insert("is_free_tier".to_string(), Value::from(is_free_tier));
+    *request_metadata = Some(Value::Object(metadata));
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use aether_data::repository::billing::StoredBillingModelContext;
+    use aether_usage_runtime::{UsageEvent, UsageEventData, UsageEventType};
+    use async_trait::async_trait;
+    use serde_json::json;
+    use serde_json::Value;
+
+    use super::{enrich_usage_event_with_billing, BillingModelContextLookup};
+
+    struct TestLookup {
+        context: Option<StoredBillingModelContext>,
+    }
+
+    #[async_trait]
+    impl BillingModelContextLookup for TestLookup {
+        async fn find_billing_model_context(
+            &self,
+            _provider_id: &str,
+            _provider_api_key_id: Option<&str>,
+            _global_model_name: &str,
+        ) -> Result<Option<StoredBillingModelContext>, aether_data::DataLayerError> {
+            Ok(self.context.clone())
+        }
+    }
+
+    #[tokio::test]
+    async fn enriches_completed_usage_event_with_billing_snapshot() {
+        let lookup = TestLookup {
+            context: Some(
+                StoredBillingModelContext::new(
+                    "provider-1".to_string(),
+                    Some("pay_as_you_go".to_string()),
+                    Some("key-1".to_string()),
+                    Some(json!({"openai:chat": 0.5})),
+                    Some(60),
+                    "global-model-1".to_string(),
+                    "gpt-5".to_string(),
+                    None,
+                    Some(0.02),
+                    Some(json!({"tiers":[{"up_to":null,"input_price_per_1m":3.0,"output_price_per_1m":15.0,"cache_creation_price_per_1m":3.75,"cache_read_price_per_1m":0.30}]})),
+                    Some("model-1".to_string()),
+                    Some("gpt-5-upstream".to_string()),
+                    None,
+                    None,
+                    None,
+                )
+                .expect("billing context should build"),
+            ),
+        };
+        let mut event = UsageEvent::new(
+            UsageEventType::Completed,
+            "req-billing-1",
+            UsageEventData {
+                provider_name: "OpenAI".to_string(),
+                model: "gpt-5".to_string(),
+                provider_id: Some("provider-1".to_string()),
+                provider_api_key_id: Some("key-1".to_string()),
+                request_type: Some("chat".to_string()),
+                api_format: Some("openai:chat".to_string()),
+                endpoint_api_format: Some("openai:chat".to_string()),
+                input_tokens: Some(1_000),
+                output_tokens: Some(500),
+                cache_read_input_tokens: Some(100),
+                status_code: Some(200),
+                ..UsageEventData::default()
+            },
+        );
+
+        enrich_usage_event_with_billing(&lookup, &mut event)
+            .await
+            .expect("billing should succeed");
+
+        assert!(event.data.total_cost_usd.unwrap_or_default() > 0.0);
+        assert!(event.data.actual_total_cost_usd.unwrap_or_default() > 0.0);
+        assert_eq!(
+            event
+                .data
+                .request_metadata
+                .as_ref()
+                .and_then(|value| value.get("billing_snapshot"))
+                .and_then(|value| value.get("status"))
+                .and_then(Value::as_str),
+            Some("complete")
+        );
+    }
+}

crates/aether-billing/src/lib.rs

@@ -1,4 +1,5 @@
 mod default_rule;
+mod event_enrichment;
 mod formula_engine;
 mod models;
 mod precision;
@@ -6,14 +7,17 @@ mod pricing;
 mod schema;
 mod service;
 mod token_normalization;
-mod usage_mapper;
 
+pub use aether_usage_runtime::{
+    map_usage, map_usage_from_response, StandardizedUsage, UsageMapper,
+};
 pub use default_rule::{normalize_task_type, DefaultBillingRuleGenerator, VirtualBillingRule};
+pub use event_enrichment::{enrich_usage_event_with_billing, BillingModelContextLookup};
 pub use formula_engine::{
     extract_variable_names, BillingIncompleteError, ExpressionEvaluationError, FormulaEngine,
     FormulaEvaluationResult, FormulaEvaluationStatus, UnsafeExpressionError,
 };
-pub use models::{BillingDimension, BillingUnit, CostBreakdown, StandardizedUsage};
+pub use models::{BillingDimension, BillingUnit, CostBreakdown};
 pub use precision::{
     quantize_cost, quantize_display, quantize_value, BILLING_DISPLAY_PRECISION,
     BILLING_STORAGE_PRECISION,
@@ -24,4 +28,3 @@ pub use schema::{
 };
 pub use service::BillingService;
 pub use token_normalization::normalize_input_tokens_for_billing;
-pub use usage_mapper::{map_usage, map_usage_from_response, UsageMapper};

crates/aether-billing/src/models.rs

@@ -33,63 +33,6 @@ impl BillingDimension {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize, Default)]
-pub struct StandardizedUsage {
-    pub input_tokens: i64,
-    pub output_tokens: i64,
-    pub cache_creation_tokens: i64,
-    pub cache_read_tokens: i64,
-    pub reasoning_tokens: i64,
-    pub cache_storage_token_hours: f64,
-    pub request_count: i64,
-    pub dimensions: BTreeMap<String, serde_json::Value>,
-}
-
-impl StandardizedUsage {
-    pub fn new() -> Self {
-        Self {
-            request_count: 1,
-            ..Self::default()
-        }
-    }
-
-    pub fn get(&self, field_name: &str) -> Option<serde_json::Value> {
-        match field_name {
-            "input_tokens" => Some(serde_json::json!(self.input_tokens)),
-            "output_tokens" => Some(serde_json::json!(self.output_tokens)),
-            "cache_creation_tokens" => Some(serde_json::json!(self.cache_creation_tokens)),
-            "cache_read_tokens" => Some(serde_json::json!(self.cache_read_tokens)),
-            "reasoning_tokens" => Some(serde_json::json!(self.reasoning_tokens)),
-            "cache_storage_token_hours" => Some(serde_json::json!(self.cache_storage_token_hours)),
-            "request_count" => Some(serde_json::json!(self.request_count)),
-            "extra" | "dimensions" => Some(serde_json::json!(self.dimensions)),
-            _ => self.dimensions.get(field_name).cloned(),
-        }
-    }
-
-    pub fn set(&mut self, field_name: &str, value: impl Into<serde_json::Value>) {
-        let value = value.into();
-        match field_name {
-            "input_tokens" => self.input_tokens = as_i64(&value, 0),
-            "output_tokens" => self.output_tokens = as_i64(&value, 0),
-            "cache_creation_tokens" => self.cache_creation_tokens = as_i64(&value, 0),
-            "cache_read_tokens" => self.cache_read_tokens = as_i64(&value, 0),
-            "reasoning_tokens" => self.reasoning_tokens = as_i64(&value, 0),
-            "cache_storage_token_hours" => self.cache_storage_token_hours = as_f64(&value, 0.0),
-            "request_count" => self.request_count = as_i64(&value, 0),
-            "extra" | "dimensions" => {
-                self.dimensions = match value {
-                    serde_json::Value::Object(map) => map.into_iter().collect(),
-                    _ => BTreeMap::new(),
-                }
-            }
-            _ => {
-                self.dimensions.insert(field_name.to_string(), value);
-            }
-        }
-    }
-}
-
 #[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize, Default)]
 pub struct CostBreakdown {
     pub costs: BTreeMap<String, f64>,
@@ -98,20 +41,9 @@ pub struct CostBreakdown {
     pub effective_prices: BTreeMap<String, f64>,
 }
 
-fn as_i64(value: &serde_json::Value, default: i64) -> i64 {
-    value
-        .as_i64()
-        .or_else(|| value.as_u64().and_then(|v| i64::try_from(v).ok()))
-        .unwrap_or(default)
-}
-
-fn as_f64(value: &serde_json::Value, default: f64) -> f64 {
-    value.as_f64().unwrap_or(default)
-}
-
 #[cfg(test)]
 mod tests {
-    use super::{BillingDimension, BillingUnit, StandardizedUsage};
+    use super::{BillingDimension, BillingUnit};
 
     #[test]
     fn dimension_calculates_per_million_tokens() {
@@ -124,17 +56,4 @@ mod tests {
         };
         assert_eq!(dimension.calculate(500_000.0, 2.0), 1.0);
     }
-
-    #[test]
-    fn standardized_usage_reads_and_writes_known_and_extra_fields() {
-        let mut usage = StandardizedUsage::new();
-        usage.set("input_tokens", 10);
-        usage.set("custom_dimension", "value");
-
-        assert_eq!(usage.get("input_tokens"), Some(serde_json::json!(10)));
-        assert_eq!(
-            usage.get("custom_dimension"),
-            Some(serde_json::json!("value"))
-        );
-    }
 }

crates/aether-billing/src/usage_mapper.rs

@@ -1,190 +0,0 @@
-use std::collections::BTreeMap;
-
-use crate::models::StandardizedUsage;
-
-pub struct UsageMapper;
-
-impl UsageMapper {
-    pub fn map(
-        raw_usage: &serde_json::Value,
-        api_format: &str,
-        extra_mapping: Option<&BTreeMap<String, String>>,
-    ) -> StandardizedUsage {
-        if !raw_usage.is_object() {
-            return StandardizedUsage::new();
-        }
-
-        let mut usage = StandardizedUsage::new();
-        let mut mapping = base_mapping(api_format);
-        if let Some(extra_mapping) = extra_mapping {
-            mapping.extend(extra_mapping.clone());
-        }
-
-        for (source_path, target_field) in mapping {
-            if let Some(value) = get_nested_value(raw_usage, &source_path) {
-                usage.set(&target_field, value.clone());
-            }
-        }
-
-        usage
-    }
-
-    pub fn map_from_response(response: &serde_json::Value, api_format: &str) -> StandardizedUsage {
-        let family = api_family(api_format);
-        let usage_value = if family == "gemini" {
-            response
-                .get("usageMetadata")
-                .or_else(|| {
-                    response
-                        .get("candidates")
-                        .and_then(|v| v.get(0))
-                        .and_then(|v| v.get("usageMetadata"))
-                })
-                .unwrap_or(&serde_json::Value::Null)
-        } else {
-            response.get("usage").unwrap_or(&serde_json::Value::Null)
-        };
-        Self::map(usage_value, api_format, None)
-    }
-}
-
-pub fn map_usage(raw_usage: &serde_json::Value, api_format: &str) -> StandardizedUsage {
-    UsageMapper::map(raw_usage, api_format, None)
-}
-
-pub fn map_usage_from_response(
-    response: &serde_json::Value,
-    api_format: &str,
-) -> StandardizedUsage {
-    UsageMapper::map_from_response(response, api_format)
-}
-
-fn api_family(api_format: &str) -> String {
-    api_format
-        .split(':')
-        .next()
-        .unwrap_or_default()
-        .trim()
-        .to_ascii_lowercase()
-}
-
-fn base_mapping(api_format: &str) -> BTreeMap<String, String> {
-    let mut mapping = BTreeMap::new();
-    match api_family(api_format).as_str() {
-        "openai" => {
-            mapping.insert("prompt_tokens".to_string(), "input_tokens".to_string());
-            mapping.insert("completion_tokens".to_string(), "output_tokens".to_string());
-            mapping.insert(
-                "prompt_tokens_details.cached_tokens".to_string(),
-                "cache_read_tokens".to_string(),
-            );
-            mapping.insert(
-                "completion_tokens_details.reasoning_tokens".to_string(),
-                "reasoning_tokens".to_string(),
-            );
-        }
-        "gemini" => {
-            mapping.insert("promptTokenCount".to_string(), "input_tokens".to_string());
-            mapping.insert(
-                "candidatesTokenCount".to_string(),
-                "output_tokens".to_string(),
-            );
-            mapping.insert(
-                "cachedContentTokenCount".to_string(),
-                "cache_read_tokens".to_string(),
-            );
-            mapping.insert(
-                "usageMetadata.promptTokenCount".to_string(),
-                "input_tokens".to_string(),
-            );
-            mapping.insert(
-                "usageMetadata.candidatesTokenCount".to_string(),
-                "output_tokens".to_string(),
-            );
-            mapping.insert(
-                "usageMetadata.cachedContentTokenCount".to_string(),
-                "cache_read_tokens".to_string(),
-            );
-        }
-        _ => {
-            mapping.insert("input_tokens".to_string(), "input_tokens".to_string());
-            mapping.insert("output_tokens".to_string(), "output_tokens".to_string());
-            mapping.insert(
-                "cache_creation_input_tokens".to_string(),
-                "cache_creation_tokens".to_string(),
-            );
-            mapping.insert(
-                "cache_read_input_tokens".to_string(),
-                "cache_read_tokens".to_string(),
-            );
-        }
-    }
-    mapping
-}
-
-fn get_nested_value<'a>(value: &'a serde_json::Value, path: &str) -> Option<&'a serde_json::Value> {
-    let mut current = value;
-    for segment in path.split('.') {
-        current = current.get(segment)?;
-    }
-    Some(current)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::{map_usage, map_usage_from_response};
-
-    #[test]
-    fn maps_openai_usage() {
-        let usage = map_usage(
-            &serde_json::json!({
-                "prompt_tokens": 12,
-                "completion_tokens": 8,
-                "prompt_tokens_details": { "cached_tokens": 2 },
-                "completion_tokens_details": { "reasoning_tokens": 3 }
-            }),
-            "openai:chat",
-        );
-
-        assert_eq!(usage.input_tokens, 12);
-        assert_eq!(usage.output_tokens, 8);
-        assert_eq!(usage.cache_read_tokens, 2);
-        assert_eq!(usage.reasoning_tokens, 3);
-    }
-
-    #[test]
-    fn maps_claude_usage() {
-        let usage = map_usage(
-            &serde_json::json!({
-                "input_tokens": 10,
-                "output_tokens": 5,
-                "cache_creation_input_tokens": 4,
-                "cache_read_input_tokens": 1
-            }),
-            "claude:chat",
-        );
-
-        assert_eq!(usage.input_tokens, 10);
-        assert_eq!(usage.output_tokens, 5);
-        assert_eq!(usage.cache_creation_tokens, 4);
-        assert_eq!(usage.cache_read_tokens, 1);
-    }
-
-    #[test]
-    fn maps_gemini_usage_from_response() {
-        let usage = map_usage_from_response(
-            &serde_json::json!({
-                "usageMetadata": {
-                    "promptTokenCount": 14,
-                    "candidatesTokenCount": 6,
-                    "cachedContentTokenCount": 2
-                }
-            }),
-            "gemini:chat",
-        );
-
-        assert_eq!(usage.input_tokens, 14);
-        assert_eq!(usage.output_tokens, 6);
-        assert_eq!(usage.cache_read_tokens, 2);
-    }
-}