refactor: 大规模模块拆分与代码精简，新增 ai-pipeline/data-contracts 独立 crate

- 新增 aether-ai-pipeline 和 aether-data-contracts crate，将 pipeline 逻辑与数据契约从 gateway 中解耦
- 重构 admin handlers：拆分单体模块为 auth/billing/endpoint/features/model/observability/provider/system 等独立子模块
- 合并 chat/cli 重复代码路径：精简 conversion、finalize、planner 中的 sync/chat/cli 分支
- 重构 scheduler/executor/data 层，引入 facade 模式降低模块间耦合
- 移除冗余的 intent 模块，将 plan_fallback/policy/stream_path/sync_path 迁移至 executor
- 前端适配：调整 admin API 调用和 provider 模型测试对话框

apps/aether-gateway/src/handlers/admin/model/catalog_routes.rs

@@ -0,0 +1,77 @@
+use crate::control::GatewayPublicRequestContext;
+use crate::handlers::admin::model::{
+    build_admin_model_catalog_payload, clear_admin_external_models_cache,
+    read_admin_external_models_cache,
+};
+use crate::{AppState, GatewayError};
+use axum::{
+    body::Body,
+    http,
+    response::{IntoResponse, Response},
+    Json,
+};
+use serde_json::json;
+
+const ADMIN_MODEL_CATALOG_DATA_UNAVAILABLE_DETAIL: &str = "Admin model catalog data unavailable";
+
+fn build_admin_model_catalog_data_unavailable_response() -> Response<Body> {
+    (
+        http::StatusCode::SERVICE_UNAVAILABLE,
+        Json(json!({ "detail": ADMIN_MODEL_CATALOG_DATA_UNAVAILABLE_DETAIL })),
+    )
+        .into_response()
+}
+
+pub(crate) async fn maybe_build_local_admin_model_catalog_response(
+    state: &AppState,
+    request_context: &GatewayPublicRequestContext,
+) -> Result<Option<Response<Body>>, GatewayError> {
+    let Some(decision) = request_context.control_decision.as_ref() else {
+        return Ok(None);
+    };
+
+    if decision.route_family.as_deref() == Some("model_catalog_manage")
+        && decision.route_kind.as_deref() == Some("catalog")
+        && request_context.request_method == http::Method::GET
+        && request_context.request_path == "/api/admin/models/catalog"
+    {
+        if !state.has_global_model_data_reader() || !state.has_provider_catalog_data_reader() {
+            return Ok(Some(build_admin_model_catalog_data_unavailable_response()));
+        }
+        let Some(payload) = build_admin_model_catalog_payload(state).await else {
+            return Ok(Some(build_admin_model_catalog_data_unavailable_response()));
+        };
+        return Ok(Some(Json(payload).into_response()));
+    }
+
+    if decision.route_family.as_deref() == Some("model_external_manage")
+        && decision.route_kind.as_deref() == Some("external")
+        && request_context.request_method == http::Method::GET
+        && request_context.request_path == "/api/admin/models/external"
+    {
+        return Ok(Some(
+            match read_admin_external_models_cache(state).await? {
+                Some(payload) => Json(payload).into_response(),
+                None => (
+                    http::StatusCode::SERVICE_UNAVAILABLE,
+                    Json(json!({
+                        "detail": "External models catalog requires Rust admin backend"
+                    })),
+                )
+                    .into_response(),
+            },
+        ));
+    }
+
+    if decision.route_family.as_deref() == Some("model_external_manage")
+        && decision.route_kind.as_deref() == Some("clear_external_cache")
+        && request_context.request_method == http::Method::DELETE
+        && request_context.request_path == "/api/admin/models/external/cache"
+    {
+        return Ok(Some(
+            Json(clear_admin_external_models_cache(state).await?).into_response(),
+        ));
+    }
+
+    Ok(None)
+}

apps/aether-gateway/src/handlers/admin/model/external_cache.rs

@@ -0,0 +1,231 @@
+use crate::handlers::shared::mark_external_models_official_providers;
+use crate::{AppState, GatewayError};
+use serde_json::json;
+use tracing::warn;
+
+const ADMIN_EXTERNAL_MODELS_CACHE_KEY: &str = "aether:external:models_dev";
+const ADMIN_EXTERNAL_MODELS_CACHE_TTL_SECS: u64 = 15 * 60;
+const ADMIN_EXTERNAL_MODELS_SOURCE_URL_ENV: &str = "AETHER_GATEWAY_EXTERNAL_MODELS_URL";
+const ADMIN_EXTERNAL_MODELS_SOURCE_URL_DEFAULT: &str = "https://models.dev/api.json";
+
+fn admin_external_models_source_url() -> String {
+    std::env::var(ADMIN_EXTERNAL_MODELS_SOURCE_URL_ENV)
+        .ok()
+        .map(|value| value.trim().to_string())
+        .filter(|value| !value.is_empty())
+        .unwrap_or_else(|| ADMIN_EXTERNAL_MODELS_SOURCE_URL_DEFAULT.to_string())
+}
+
+fn normalize_admin_external_models_payload(payload: serde_json::Value) -> serde_json::Value {
+    mark_external_models_official_providers(&payload).unwrap_or(payload)
+}
+
+async fn store_admin_external_models_cache(
+    state: &AppState,
+    payload: &serde_json::Value,
+) -> Result<(), GatewayError> {
+    let Some(runner) = state.redis_kv_runner() else {
+        return Ok(());
+    };
+    let serialized =
+        serde_json::to_string(payload).map_err(|err| GatewayError::Internal(err.to_string()))?;
+    runner
+        .setex(
+            ADMIN_EXTERNAL_MODELS_CACHE_KEY,
+            &serialized,
+            Some(ADMIN_EXTERNAL_MODELS_CACHE_TTL_SECS),
+        )
+        .await
+        .map_err(|err| GatewayError::Internal(err.to_string()))?;
+    Ok(())
+}
+
+async fn fetch_admin_external_models_from_source(
+    state: &AppState,
+) -> Result<serde_json::Value, GatewayError> {
+    let url = admin_external_models_source_url();
+    let response = state
+        .client
+        .get(&url)
+        .send()
+        .await
+        .map_err(|err| GatewayError::Internal(err.to_string()))?;
+    let response = response
+        .error_for_status()
+        .map_err(|err| GatewayError::Internal(err.to_string()))?;
+    let payload = response
+        .json::<serde_json::Value>()
+        .await
+        .map_err(|err| GatewayError::Internal(err.to_string()))?;
+    Ok(normalize_admin_external_models_payload(payload))
+}
+
+pub(crate) async fn read_admin_external_models_cache(
+    state: &AppState,
+) -> Result<Option<serde_json::Value>, GatewayError> {
+    if let Some(runner) = state.redis_kv_runner() {
+        match runner.client().get_multiplexed_async_connection().await {
+            Ok(mut connection) => {
+                let namespaced_key = runner.keyspace().key(ADMIN_EXTERNAL_MODELS_CACHE_KEY);
+                match redis::cmd("GET")
+                    .arg(&namespaced_key)
+                    .query_async::<Option<String>>(&mut connection)
+                    .await
+                {
+                    Ok(Some(raw)) => match serde_json::from_str::<serde_json::Value>(&raw) {
+                        Ok(payload) => {
+                            let payload = normalize_admin_external_models_payload(payload);
+                            if let Err(err) =
+                                store_admin_external_models_cache(state, &payload).await
+                            {
+                                warn!(error = ?err, "failed to refresh external models cache ttl");
+                            }
+                            return Ok(Some(payload));
+                        }
+                        Err(err) => {
+                            warn!(error = %err, "failed to parse cached external models payload");
+                        }
+                    },
+                    Ok(None) => {}
+                    Err(err) => {
+                        warn!(error = %err, "failed to read external models cache");
+                    }
+                }
+            }
+            Err(err) => {
+                warn!(error = %err, "failed to connect to redis for external models cache");
+            }
+        }
+    }
+
+    match fetch_admin_external_models_from_source(state).await {
+        Ok(payload) => {
+            if let Err(err) = store_admin_external_models_cache(state, &payload).await {
+                warn!(error = ?err, "failed to store fetched external models cache");
+            }
+            Ok(Some(payload))
+        }
+        Err(err) => {
+            warn!(error = ?err, "failed to fetch external models catalog");
+            Ok(None)
+        }
+    }
+}
+
+pub(crate) async fn clear_admin_external_models_cache(
+    state: &AppState,
+) -> Result<serde_json::Value, GatewayError> {
+    let Some(runner) = state.redis_kv_runner() else {
+        return Ok(json!({
+            "cleared": false,
+            "message": "Redis 未启用",
+        }));
+    };
+    let deleted = runner
+        .del(ADMIN_EXTERNAL_MODELS_CACHE_KEY)
+        .await
+        .map_err(|err| GatewayError::Internal(err.to_string()))?;
+    Ok(json!({
+        "cleared": deleted > 0,
+        "message": if deleted > 0 { "缓存已清除" } else { "缓存不存在" },
+    }))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{
+        admin_external_models_source_url, normalize_admin_external_models_payload,
+        read_admin_external_models_cache, ADMIN_EXTERNAL_MODELS_SOURCE_URL_ENV,
+    };
+    use crate::tests::{start_server, AppState};
+    use axum::routing::get;
+    use axum::{Json, Router};
+    use serde_json::json;
+
+    struct TestEnvVarGuard {
+        key: &'static str,
+        previous: Option<String>,
+    }
+
+    impl Drop for TestEnvVarGuard {
+        fn drop(&mut self) {
+            if let Some(previous) = self.previous.as_deref() {
+                std::env::set_var(self.key, previous);
+            } else {
+                std::env::remove_var(self.key);
+            }
+        }
+    }
+
+    fn set_test_env_var(key: &'static str, value: &str) -> TestEnvVarGuard {
+        let previous = std::env::var(key).ok();
+        std::env::set_var(key, value);
+        TestEnvVarGuard { key, previous }
+    }
+
+    #[test]
+    fn normalizes_external_models_payload_with_official_flags() {
+        let payload = json!({
+            "openai": {
+                "name": "OpenAI",
+                "models": {}
+            },
+            "openrouter": {
+                "name": "OpenRouter",
+                "models": {}
+            }
+        });
+
+        let normalized = normalize_admin_external_models_payload(payload);
+
+        assert_eq!(normalized["openai"]["official"], json!(true));
+        assert_eq!(normalized["openrouter"]["official"], json!(false));
+    }
+
+    #[test]
+    fn external_models_source_url_uses_env_override_when_present() {
+        let _guard = set_test_env_var(
+            ADMIN_EXTERNAL_MODELS_SOURCE_URL_ENV,
+            "http://127.0.0.1:12345/api",
+        );
+        assert_eq!(
+            admin_external_models_source_url(),
+            "http://127.0.0.1:12345/api"
+        );
+    }
+
+    #[tokio::test]
+    async fn read_external_models_fetches_remote_payload_when_cache_missing() {
+        let upstream = Router::new().route(
+            "/api.json",
+            get(|| async {
+                Json(json!({
+                    "openai": {
+                        "name": "OpenAI",
+                        "models": {
+                            "gpt-5": {
+                                "name": "GPT-5"
+                            }
+                        }
+                    }
+                }))
+            }),
+        );
+        let (upstream_url, upstream_handle) = start_server(upstream).await;
+        let _guard = set_test_env_var(
+            ADMIN_EXTERNAL_MODELS_SOURCE_URL_ENV,
+            &format!("{upstream_url}/api.json"),
+        );
+
+        let state = AppState::new().expect("gateway should build");
+        let payload = read_admin_external_models_cache(&state)
+            .await
+            .expect("external models read should succeed")
+            .expect("payload should be fetched");
+
+        assert_eq!(payload["openai"]["official"], json!(true));
+        assert_eq!(payload["openai"]["models"]["gpt-5"]["name"], json!("GPT-5"));
+
+        upstream_handle.abort();
+    }
+}

apps/aether-gateway/src/handlers/admin/model/global.rs

@@ -0,0 +1,414 @@
+use super::payloads::{
+    admin_provider_model_effective_capability, admin_provider_model_effective_input_price,
+    admin_provider_model_effective_output_price, model_tiered_pricing_first_tier_value,
+    timestamp_or_now,
+};
+use crate::handlers::admin::shared::json_string_list;
+use crate::AppState;
+use aether_data_contracts::repository::global_models::{
+    AdminGlobalModelListQuery, StoredAdminGlobalModel, StoredAdminProviderModel,
+};
+use futures_util::stream::{self, StreamExt};
+use serde_json::json;
+use std::collections::{BTreeMap, BTreeSet};
+use std::time::{SystemTime, UNIX_EPOCH};
+
+pub(crate) async fn resolve_admin_global_model_by_id_or_err(
+    state: &AppState,
+    global_model_id: &str,
+) -> Result<StoredAdminGlobalModel, String> {
+    state
+        .get_admin_global_model_by_id(global_model_id)
+        .await
+        .map_err(|err| format!("{err:?}"))?
+        .ok_or_else(|| format!("GlobalModel {global_model_id} 不存在"))
+}
+
+fn admin_global_model_provider_counts(
+    provider_models: &[StoredAdminProviderModel],
+) -> (usize, usize, usize) {
+    let total_models = provider_models.len();
+    let total_providers = provider_models
+        .iter()
+        .map(|model| model.provider_id.clone())
+        .collect::<BTreeSet<_>>()
+        .len();
+    let active_provider_count = provider_models
+        .iter()
+        .filter(|model| model.is_active && model.is_available)
+        .map(|model| model.provider_id.clone())
+        .collect::<BTreeSet<_>>()
+        .len();
+    (total_models, total_providers, active_provider_count)
+}
+
+fn build_admin_global_model_price_range(
+    global_model: &StoredAdminGlobalModel,
+    provider_models: &[StoredAdminProviderModel],
+) -> serde_json::Value {
+    let mut input_values = provider_models
+        .iter()
+        .filter_map(admin_provider_model_effective_input_price)
+        .collect::<Vec<_>>();
+    let mut output_values = provider_models
+        .iter()
+        .filter_map(admin_provider_model_effective_output_price)
+        .collect::<Vec<_>>();
+
+    if input_values.is_empty() {
+        if let Some(value) = model_tiered_pricing_first_tier_value(
+            global_model.default_tiered_pricing.as_ref(),
+            "input_price_per_1m",
+        ) {
+            input_values.push(value);
+        }
+    }
+    if output_values.is_empty() {
+        if let Some(value) = model_tiered_pricing_first_tier_value(
+            global_model.default_tiered_pricing.as_ref(),
+            "output_price_per_1m",
+        ) {
+            output_values.push(value);
+        }
+    }
+
+    json!({
+        "min_input": input_values.iter().copied().reduce(f64::min),
+        "max_input": input_values.iter().copied().reduce(f64::max),
+        "min_output": output_values.iter().copied().reduce(f64::min),
+        "max_output": output_values.iter().copied().reduce(f64::max),
+    })
+}
+
+async fn admin_global_model_provider_models_by_global_model_id(
+    state: &AppState,
+    global_model_ids: &[String],
+) -> BTreeMap<String, Vec<StoredAdminProviderModel>> {
+    let state = state.clone();
+    stream::iter(global_model_ids.iter().cloned().map(|global_model_id| {
+        let state = state.clone();
+        async move {
+            let provider_models = state
+                .list_admin_provider_models_by_global_model_id(&global_model_id)
+                .await
+                .ok()
+                .unwrap_or_default();
+            (global_model_id, provider_models)
+        }
+    }))
+    .buffer_unordered(32)
+    .collect::<Vec<_>>()
+    .await
+    .into_iter()
+    .collect()
+}
+
+pub(crate) fn build_admin_global_model_response(
+    global_model: &StoredAdminGlobalModel,
+    provider_models: &[StoredAdminProviderModel],
+    now_unix_secs: u64,
+) -> serde_json::Value {
+    let (_, provider_count, active_provider_count) =
+        admin_global_model_provider_counts(provider_models);
+    json!({
+        "id": &global_model.id,
+        "name": &global_model.name,
+        "display_name": &global_model.display_name,
+        "is_active": global_model.is_active,
+        "default_price_per_request": global_model.default_price_per_request,
+        "default_tiered_pricing": global_model.default_tiered_pricing.clone(),
+        "supported_capabilities": json_string_list(global_model.supported_capabilities.as_ref()),
+        "config": global_model.config.clone(),
+        "provider_count": provider_count,
+        "active_provider_count": active_provider_count,
+        "created_at": timestamp_or_now(global_model.created_at_unix_secs, now_unix_secs),
+        "updated_at": timestamp_or_now(global_model.updated_at_unix_secs, now_unix_secs),
+    })
+}
+
+pub(crate) async fn build_admin_global_models_payload(
+    state: &AppState,
+    skip: usize,
+    limit: usize,
+    is_active: Option<bool>,
+    search: Option<String>,
+) -> Option<serde_json::Value> {
+    if !state.has_global_model_data_reader() {
+        return None;
+    }
+    let page = state
+        .list_admin_global_models(&AdminGlobalModelListQuery {
+            offset: skip,
+            limit,
+            is_active,
+            search,
+        })
+        .await
+        .ok()?;
+    let now_unix_secs = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .ok()
+        .map(|duration| duration.as_secs())
+        .unwrap_or(0);
+    let mut models = page.items;
+    models.sort_by(|left, right| {
+        left.name
+            .cmp(&right.name)
+            .then_with(|| left.id.cmp(&right.id))
+    });
+    let global_model_ids = models
+        .iter()
+        .map(|model| model.id.clone())
+        .collect::<Vec<_>>();
+    let mut provider_models_by_global_model =
+        admin_global_model_provider_models_by_global_model_id(state, &global_model_ids).await;
+    let mut payload_models = Vec::with_capacity(models.len());
+    for model in models {
+        let provider_models = provider_models_by_global_model
+            .remove(&model.id)
+            .unwrap_or_default();
+        payload_models.push(build_admin_global_model_response(
+            &model,
+            &provider_models,
+            now_unix_secs,
+        ));
+    }
+    Some(json!({
+        "models": payload_models,
+        "total": page.total,
+    }))
+}
+
+pub(crate) async fn build_admin_global_model_payload(
+    state: &AppState,
+    global_model_id: &str,
+) -> Option<serde_json::Value> {
+    if !state.has_global_model_data_reader() {
+        return None;
+    }
+    let model = state
+        .get_admin_global_model_by_id(global_model_id)
+        .await
+        .ok()??;
+    let provider_models = state
+        .list_admin_provider_models_by_global_model_id(&model.id)
+        .await
+        .ok()
+        .unwrap_or_default();
+    let now_unix_secs = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .ok()
+        .map(|duration| duration.as_secs())
+        .unwrap_or(0);
+    let (total_models, total_providers, _) = admin_global_model_provider_counts(&provider_models);
+    let mut payload = build_admin_global_model_response(&model, &provider_models, now_unix_secs);
+    if let Some(object) = payload.as_object_mut() {
+        object.insert("total_models".to_string(), json!(total_models));
+        object.insert("total_providers".to_string(), json!(total_providers));
+        object.insert(
+            "price_range".to_string(),
+            build_admin_global_model_price_range(&model, &provider_models),
+        );
+    }
+    Some(payload)
+}
+
+pub(crate) async fn build_admin_global_model_providers_payload(
+    state: &AppState,
+    global_model_id: &str,
+) -> Option<serde_json::Value> {
+    if !state.has_global_model_data_reader() || !state.has_provider_catalog_data_reader() {
+        return None;
+    }
+    let global_model = state
+        .get_admin_global_model_by_id(global_model_id)
+        .await
+        .ok()??;
+    let provider_models = state
+        .list_admin_provider_models_by_global_model_id(&global_model.id)
+        .await
+        .ok()?;
+    let provider_ids = provider_models
+        .iter()
+        .map(|model| model.provider_id.clone())
+        .collect::<Vec<_>>();
+    let provider_by_id = state
+        .read_provider_catalog_providers_by_ids(&provider_ids)
+        .await
+        .ok()?
+        .into_iter()
+        .map(|provider| (provider.id.clone(), provider))
+        .collect::<BTreeMap<_, _>>();
+    let mut providers = provider_models
+        .into_iter()
+        .filter_map(|model| {
+            let provider = provider_by_id.get(&model.provider_id)?;
+            Some(json!({
+                "provider_id": provider.id,
+                "provider_name": provider.name,
+                "model_id": model.id,
+                "target_model": model.provider_model_name,
+                "input_price_per_1m": admin_provider_model_effective_input_price(&model),
+                "output_price_per_1m": admin_provider_model_effective_output_price(&model),
+                "price_per_request": model.price_per_request.or(model.global_model_default_price_per_request),
+                "effective_tiered_pricing": model
+                    .tiered_pricing
+                    .clone()
+                    .or(model.global_model_default_tiered_pricing.clone()),
+                "supports_vision": admin_provider_model_effective_capability(&model, "vision"),
+                "supports_function_calling": admin_provider_model_effective_capability(&model, "function_calling"),
+                "supports_streaming": admin_provider_model_effective_capability(&model, "streaming"),
+                "is_active": model.is_active,
+            }))
+        })
+        .collect::<Vec<_>>();
+    providers.sort_by(|left, right| {
+        left.get("provider_name")
+            .and_then(serde_json::Value::as_str)
+            .cmp(
+                &right
+                    .get("provider_name")
+                    .and_then(serde_json::Value::as_str),
+            )
+    });
+    let total = providers.len();
+    Some(json!({
+        "providers": providers,
+        "total": total,
+    }))
+}
+
+pub(crate) async fn build_admin_model_catalog_payload(
+    state: &AppState,
+) -> Option<serde_json::Value> {
+    if !state.has_global_model_data_reader() || !state.has_provider_catalog_data_reader() {
+        return None;
+    }
+    let global_models = state
+        .list_admin_global_models(&AdminGlobalModelListQuery {
+            offset: 0,
+            limit: 10_000,
+            is_active: Some(true),
+            search: None,
+        })
+        .await
+        .ok()?
+        .items;
+    let provider_ids = state
+        .list_provider_catalog_providers(false)
+        .await
+        .ok()?
+        .into_iter()
+        .map(|provider| (provider.id.clone(), provider))
+        .collect::<BTreeMap<_, _>>();
+    let mut models = Vec::new();
+    for global_model in global_models {
+        let provider_models = state
+            .list_admin_provider_models_by_global_model_id(&global_model.id)
+            .await
+            .ok()
+            .unwrap_or_default();
+        let price_range = build_admin_global_model_price_range(&global_model, &provider_models);
+        let mut providers = Vec::new();
+        let mut supports_vision = global_model
+            .config
+            .as_ref()
+            .and_then(|value| value.get("vision"))
+            .and_then(serde_json::Value::as_bool)
+            .unwrap_or(false);
+        let mut supports_function_calling = global_model
+            .config
+            .as_ref()
+            .and_then(|value| value.get("function_calling"))
+            .and_then(serde_json::Value::as_bool)
+            .unwrap_or(false);
+        let mut supports_streaming = global_model
+            .config
+            .as_ref()
+            .and_then(|value| value.get("streaming"))
+            .and_then(serde_json::Value::as_bool)
+            .unwrap_or(false);
+
+        for model in provider_models {
+            let Some(provider) = provider_ids.get(&model.provider_id) else {
+                continue;
+            };
+            let effective_tiered_pricing = model
+                .tiered_pricing
+                .clone()
+                .or_else(|| model.global_model_default_tiered_pricing.clone());
+            let tier_count = effective_tiered_pricing
+                .as_ref()
+                .and_then(|value| value.get("tiers"))
+                .and_then(serde_json::Value::as_array)
+                .map(Vec::len)
+                .unwrap_or(1);
+            let model_supports_vision = admin_provider_model_effective_capability(&model, "vision");
+            let model_supports_function_calling =
+                admin_provider_model_effective_capability(&model, "function_calling");
+            let model_supports_streaming =
+                admin_provider_model_effective_capability(&model, "streaming");
+            supports_vision |= model_supports_vision;
+            supports_function_calling |= model_supports_function_calling;
+            supports_streaming |= model_supports_streaming;
+            providers.push(json!({
+                "provider_id": provider.id,
+                "provider_name": provider.name,
+                "model_id": model.id,
+                "target_model": model.provider_model_name,
+                "input_price_per_1m": admin_provider_model_effective_input_price(&model),
+                "output_price_per_1m": admin_provider_model_effective_output_price(&model),
+                "cache_creation_price_per_1m": serde_json::Value::Null,
+                "cache_read_price_per_1m": serde_json::Value::Null,
+                "cache_1h_creation_price_per_1m": serde_json::Value::Null,
+                "price_per_request": model.price_per_request.or(model.global_model_default_price_per_request),
+                "effective_tiered_pricing": effective_tiered_pricing,
+                "tier_count": tier_count,
+                "supports_vision": model_supports_vision,
+                "supports_function_calling": model_supports_function_calling,
+                "supports_streaming": model_supports_streaming,
+                "is_active": model.is_active,
+            }));
+        }
+        providers.sort_by(|left, right| {
+            left.get("provider_name")
+                .and_then(serde_json::Value::as_str)
+                .cmp(
+                    &right
+                        .get("provider_name")
+                        .and_then(serde_json::Value::as_str),
+                )
+        });
+        models.push(json!({
+            "global_model_name": global_model.name,
+            "display_name": global_model.display_name,
+            "description": global_model
+                .config
+                .as_ref()
+                .and_then(|value| value.get("description"))
+                .and_then(serde_json::Value::as_str),
+            "providers": providers,
+            "price_range": price_range,
+            "total_providers": providers.len(),
+            "capabilities": json!({
+                "supports_vision": supports_vision,
+                "supports_function_calling": supports_function_calling,
+                "supports_streaming": supports_streaming,
+            }),
+        }));
+    }
+    let total = models.len();
+    models.sort_by(|left, right| {
+        left.get("global_model_name")
+            .and_then(serde_json::Value::as_str)
+            .cmp(
+                &right
+                    .get("global_model_name")
+                    .and_then(serde_json::Value::as_str),
+            )
+    });
+    Some(json!({
+        "models": models,
+        "total": total,
+    }))
+}

apps/aether-gateway/src/handlers/admin/model/global_models/helpers.rs

@@ -0,0 +1,18 @@
+use axum::{
+    body::Body,
+    http,
+    response::{IntoResponse, Response},
+    Json,
+};
+use serde_json::json;
+
+pub(super) const ADMIN_GLOBAL_MODELS_DATA_UNAVAILABLE_DETAIL: &str =
+    "Admin global model data unavailable";
+
+pub(super) fn build_admin_global_models_data_unavailable_response() -> Response<Body> {
+    (
+        http::StatusCode::SERVICE_UNAVAILABLE,
+        Json(json!({ "detail": ADMIN_GLOBAL_MODELS_DATA_UNAVAILABLE_DETAIL })),
+    )
+        .into_response()
+}

apps/aether-gateway/src/handlers/admin/model/global_models/mod.rs

@@ -0,0 +1,5 @@
+mod helpers;
+mod routes;
+
+use self::helpers::*;
+pub(crate) use self::routes::maybe_build_local_admin_global_models_response;

apps/aether-gateway/src/handlers/admin/model/global_models/routes.rs

@@ -0,0 +1,525 @@
+use super::super::{
+    build_admin_assign_global_model_to_providers_payload, build_admin_global_model_create_record,
+    build_admin_global_model_payload, build_admin_global_model_providers_payload,
+    build_admin_global_model_response, build_admin_global_model_routing_payload,
+    build_admin_global_model_update_record, build_admin_global_models_payload,
+    resolve_admin_global_model_by_id_or_err,
+};
+use super::helpers::{
+    build_admin_global_models_data_unavailable_response,
+    ADMIN_GLOBAL_MODELS_DATA_UNAVAILABLE_DETAIL,
+};
+use crate::control::GatewayPublicRequestContext;
+use crate::handlers::admin::model::shared::{
+    admin_global_model_assign_to_providers_id, admin_global_model_id_from_path,
+    admin_global_model_providers_id, admin_global_model_routing_id, is_admin_global_models_root,
+    AdminBatchAssignToProvidersRequest, AdminBatchDeleteIdsRequest, AdminGlobalModelCreateRequest,
+    AdminGlobalModelUpdateRequest,
+};
+use crate::handlers::admin::shared::attach_admin_audit_response;
+use crate::handlers::admin::shared::{query_param_optional_bool, query_param_value};
+use crate::{AppState, GatewayError};
+use axum::{
+    body::{Body, Bytes},
+    http,
+    response::{IntoResponse, Response},
+    Json,
+};
+use serde_json::json;
+use std::time::{SystemTime, UNIX_EPOCH};
+
+pub(crate) async fn maybe_build_local_admin_global_models_response(
+    state: &AppState,
+    request_context: &GatewayPublicRequestContext,
+    request_body: Option<&Bytes>,
+) -> Result<Option<Response<Body>>, GatewayError> {
+    let Some(decision) = request_context.control_decision.as_ref() else {
+        return Ok(None);
+    };
+
+    if decision.route_family.as_deref() == Some("global_models_manage")
+        && decision.route_kind.as_deref() == Some("routing_preview")
+        && request_context.request_method == http::Method::GET
+    {
+        if !state.has_global_model_data_reader() || !state.has_provider_catalog_data_reader() {
+            return Ok(Some(build_admin_global_models_data_unavailable_response()));
+        }
+        let Some(global_model_id) = admin_global_model_routing_id(&request_context.request_path)
+        else {
+            return Ok(Some(
+                (
+                    http::StatusCode::NOT_FOUND,
+                    Json(json!({ "detail": "GlobalModel 不存在" })),
+                )
+                    .into_response(),
+            ));
+        };
+        return Ok(Some(
+            match build_admin_global_model_routing_payload(state, &global_model_id).await {
+                Some(payload) => Json(payload).into_response(),
+                None => (
+                    http::StatusCode::NOT_FOUND,
+                    Json(json!({ "detail": format!("GlobalModel {global_model_id} 不存在") })),
+                )
+                    .into_response(),
+            },
+        ));
+    }
+
+    if decision.route_family.as_deref() == Some("global_models_manage")
+        && decision.route_kind.as_deref() == Some("list_global_models")
+        && is_admin_global_models_root(&request_context.request_path)
+    {
+        if !state.has_global_model_data_reader() {
+            return Ok(Some(build_admin_global_models_data_unavailable_response()));
+        }
+        let skip = query_param_value(request_context.request_query_string.as_deref(), "skip")
+            .and_then(|value| value.parse::<usize>().ok())
+            .unwrap_or(0);
+        let limit = query_param_value(request_context.request_query_string.as_deref(), "limit")
+            .and_then(|value| value.parse::<usize>().ok())
+            .filter(|value| *value > 0 && *value <= 1000)
+            .unwrap_or(100);
+        let is_active =
+            query_param_optional_bool(request_context.request_query_string.as_deref(), "is_active");
+        let search = query_param_value(request_context.request_query_string.as_deref(), "search");
+        let Some(payload) =
+            build_admin_global_models_payload(state, skip, limit, is_active, search).await
+        else {
+            return Ok(Some(build_admin_global_models_data_unavailable_response()));
+        };
+        return Ok(Some(Json(payload).into_response()));
+    }
+
+    if decision.route_family.as_deref() == Some("global_models_manage")
+        && decision.route_kind.as_deref() == Some("get_global_model")
+        && request_context.request_method == http::Method::GET
+    {
+        if !state.has_global_model_data_reader() {
+            return Ok(Some(build_admin_global_models_data_unavailable_response()));
+        }
+        let Some(global_model_id) = admin_global_model_id_from_path(&request_context.request_path)
+        else {
+            return Ok(Some(
+                (
+                    http::StatusCode::NOT_FOUND,
+                    Json(json!({ "detail": "GlobalModel 不存在" })),
+                )
+                    .into_response(),
+            ));
+        };
+        return Ok(Some(
+            match build_admin_global_model_payload(state, &global_model_id).await {
+                Some(payload) => Json(payload).into_response(),
+                None => (
+                    http::StatusCode::NOT_FOUND,
+                    Json(json!({ "detail": format!("GlobalModel {global_model_id} 不存在") })),
+                )
+                    .into_response(),
+            },
+        ));
+    }
+
+    if decision.route_family.as_deref() == Some("global_models_manage")
+        && decision.route_kind.as_deref() == Some("create_global_model")
+        && request_context.request_method == http::Method::POST
+        && is_admin_global_models_root(&request_context.request_path)
+    {
+        if !state.has_global_model_data_reader() || !state.has_global_model_data_writer() {
+            return Ok(Some(build_admin_global_models_data_unavailable_response()));
+        }
+        let Some(request_body) = request_body else {
+            return Ok(Some(
+                (
+                    http::StatusCode::BAD_REQUEST,
+                    Json(json!({ "detail": "请求体不能为空" })),
+                )
+                    .into_response(),
+            ));
+        };
+        let payload = match serde_json::from_slice::<AdminGlobalModelCreateRequest>(request_body) {
+            Ok(payload) => payload,
+            Err(_) => {
+                return Ok(Some(
+                    (
+                        http::StatusCode::BAD_REQUEST,
+                        Json(json!({ "detail": "请求体必须是合法的 JSON 对象" })),
+                    )
+                        .into_response(),
+                ));
+            }
+        };
+        let record = match build_admin_global_model_create_record(state, payload).await {
+            Ok(record) => record,
+            Err(detail) => {
+                return Ok(Some(
+                    (
+                        http::StatusCode::BAD_REQUEST,
+                        Json(json!({ "detail": detail })),
+                    )
+                        .into_response(),
+                ));
+            }
+        };
+        return Ok(Some(
+            match state.create_admin_global_model(&record).await? {
+                Some(created) => {
+                    let provider_models = state
+                        .list_admin_provider_models_by_global_model_id(&created.id)
+                        .await
+                        .unwrap_or_default();
+                    let now_unix_secs = SystemTime::now()
+                        .duration_since(UNIX_EPOCH)
+                        .ok()
+                        .map(|duration| duration.as_secs())
+                        .unwrap_or(0);
+                    attach_admin_audit_response(
+                        (
+                            http::StatusCode::CREATED,
+                            Json(build_admin_global_model_response(
+                                &created,
+                                &provider_models,
+                                now_unix_secs,
+                            )),
+                        )
+                            .into_response(),
+                        "admin_global_model_created",
+                        "create_global_model",
+                        "global_model",
+                        &created.id,
+                    )
+                }
+                None => (
+                    http::StatusCode::SERVICE_UNAVAILABLE,
+                    Json(json!({ "detail": ADMIN_GLOBAL_MODELS_DATA_UNAVAILABLE_DETAIL })),
+                )
+                    .into_response(),
+            },
+        ));
+    }
+
+    if decision.route_family.as_deref() == Some("global_models_manage")
+        && decision.route_kind.as_deref() == Some("update_global_model")
+        && request_context.request_method == http::Method::PATCH
+    {
+        if !state.has_global_model_data_reader() || !state.has_global_model_data_writer() {
+            return Ok(Some(build_admin_global_models_data_unavailable_response()));
+        }
+        let Some(global_model_id) = admin_global_model_id_from_path(&request_context.request_path)
+        else {
+            return Ok(Some(
+                (
+                    http::StatusCode::NOT_FOUND,
+                    Json(json!({ "detail": "GlobalModel 不存在" })),
+                )
+                    .into_response(),
+            ));
+        };
+        let existing = match resolve_admin_global_model_by_id_or_err(state, &global_model_id).await
+        {
+            Ok(model) => model,
+            Err(detail) => {
+                return Ok(Some(
+                    (
+                        http::StatusCode::NOT_FOUND,
+                        Json(json!({ "detail": detail })),
+                    )
+                        .into_response(),
+                ));
+            }
+        };
+        let Some(request_body) = request_body else {
+            return Ok(Some(
+                (
+                    http::StatusCode::BAD_REQUEST,
+                    Json(json!({ "detail": "请求体不能为空" })),
+                )
+                    .into_response(),
+            ));
+        };
+        let raw_value = match serde_json::from_slice::<serde_json::Value>(request_body) {
+            Ok(value) => value,
+            Err(_) => {
+                return Ok(Some(
+                    (
+                        http::StatusCode::BAD_REQUEST,
+                        Json(json!({ "detail": "请求体必须是合法的 JSON 对象" })),
+                    )
+                        .into_response(),
+                ));
+            }
+        };
+        let Some(raw_payload) = raw_value.as_object().cloned() else {
+            return Ok(Some(
+                (
+                    http::StatusCode::BAD_REQUEST,
+                    Json(json!({ "detail": "请求体必须是合法的 JSON 对象" })),
+                )
+                    .into_response(),
+            ));
+        };
+        let payload = match serde_json::from_value::<AdminGlobalModelUpdateRequest>(raw_value) {
+            Ok(payload) => payload,
+            Err(_) => {
+                return Ok(Some(
+                    (
+                        http::StatusCode::BAD_REQUEST,
+                        Json(json!({ "detail": "请求体必须是合法的 JSON 对象" })),
+                    )
+                        .into_response(),
+                ));
+            }
+        };
+        let record =
+            match build_admin_global_model_update_record(state, &existing, &raw_payload, payload)
+                .await
+            {
+                Ok(record) => record,
+                Err(detail) => {
+                    return Ok(Some(
+                        (
+                            http::StatusCode::BAD_REQUEST,
+                            Json(json!({ "detail": detail })),
+                        )
+                            .into_response(),
+                    ));
+                }
+            };
+        return Ok(Some(
+            match state.update_admin_global_model(&record).await? {
+                Some(updated) => {
+                    let provider_models = state
+                        .list_admin_provider_models_by_global_model_id(&updated.id)
+                        .await
+                        .unwrap_or_default();
+                    let now_unix_secs = SystemTime::now()
+                        .duration_since(UNIX_EPOCH)
+                        .ok()
+                        .map(|duration| duration.as_secs())
+                        .unwrap_or(0);
+                    attach_admin_audit_response(
+                        Json(build_admin_global_model_response(
+                            &updated,
+                            &provider_models,
+                            now_unix_secs,
+                        ))
+                        .into_response(),
+                        "admin_global_model_updated",
+                        "update_global_model",
+                        "global_model",
+                        &updated.id,
+                    )
+                }
+                None => (
+                    http::StatusCode::NOT_FOUND,
+                    Json(json!({ "detail": format!("GlobalModel {} 不存在", existing.id) })),
+                )
+                    .into_response(),
+            },
+        ));
+    }
+
+    if decision.route_family.as_deref() == Some("global_models_manage")
+        && decision.route_kind.as_deref() == Some("delete_global_model")
+        && request_context.request_method == http::Method::DELETE
+    {
+        if !state.has_global_model_data_reader() || !state.has_global_model_data_writer() {
+            return Ok(Some(build_admin_global_models_data_unavailable_response()));
+        }
+        let Some(global_model_id) = admin_global_model_id_from_path(&request_context.request_path)
+        else {
+            return Ok(Some(
+                (
+                    http::StatusCode::NOT_FOUND,
+                    Json(json!({ "detail": "GlobalModel 不存在" })),
+                )
+                    .into_response(),
+            ));
+        };
+        let existing = match resolve_admin_global_model_by_id_or_err(state, &global_model_id).await
+        {
+            Ok(model) => model,
+            Err(detail) => {
+                return Ok(Some(
+                    (
+                        http::StatusCode::NOT_FOUND,
+                        Json(json!({ "detail": detail })),
+                    )
+                        .into_response(),
+                ));
+            }
+        };
+        if !state.delete_admin_global_model(&existing.id).await? {
+            return Ok(Some(
+                (
+                    http::StatusCode::NOT_FOUND,
+                    Json(json!({ "detail": format!("GlobalModel {} 不存在", existing.id) })),
+                )
+                    .into_response(),
+            ));
+        }
+        return Ok(Some(attach_admin_audit_response(
+            http::StatusCode::NO_CONTENT.into_response(),
+            "admin_global_model_deleted",
+            "delete_global_model",
+            "global_model",
+            &existing.id,
+        )));
+    }
+
+    if decision.route_family.as_deref() == Some("global_models_manage")
+        && decision.route_kind.as_deref() == Some("batch_delete_global_models")
+        && request_context.request_method == http::Method::POST
+        && request_context.request_path == "/api/admin/models/global/batch-delete"
+    {
+        if !state.has_global_model_data_reader() || !state.has_global_model_data_writer() {
+            return Ok(Some(build_admin_global_models_data_unavailable_response()));
+        }
+        let Some(request_body) = request_body else {
+            return Ok(Some(
+                (
+                    http::StatusCode::BAD_REQUEST,
+                    Json(json!({ "detail": "请求体不能为空" })),
+                )
+                    .into_response(),
+            ));
+        };
+        let payload = match serde_json::from_slice::<AdminBatchDeleteIdsRequest>(request_body) {
+            Ok(payload) => payload,
+            Err(_) => {
+                return Ok(Some(
+                    (
+                        http::StatusCode::BAD_REQUEST,
+                        Json(json!({ "detail": "请求体必须是合法的 JSON 对象" })),
+                    )
+                        .into_response(),
+                ));
+            }
+        };
+        let mut success_count = 0usize;
+        let mut failed = Vec::new();
+        for id in payload.ids {
+            let trimmed = id.trim();
+            if trimmed.is_empty() {
+                failed.push(json!({"id": id, "error": "not found"}));
+                continue;
+            }
+            let Some(existing) = state.get_admin_global_model_by_id(trimmed).await? else {
+                failed.push(json!({"id": trimmed, "error": "not found"}));
+                continue;
+            };
+            if state.delete_admin_global_model(&existing.id).await? {
+                success_count += 1;
+            } else {
+                failed.push(json!({"id": existing.id, "error": "delete failed"}));
+            }
+        }
+        return Ok(Some(attach_admin_audit_response(
+            Json(json!({
+                "success_count": success_count,
+                "failed": failed,
+            }))
+            .into_response(),
+            "admin_global_models_batch_deleted",
+            "batch_delete_global_models",
+            "global_models_batch",
+            "batch",
+        )));
+    }
+
+    if decision.route_family.as_deref() == Some("global_models_manage")
+        && decision.route_kind.as_deref() == Some("assign_to_providers")
+        && request_context.request_method == http::Method::POST
+    {
+        let Some(global_model_id) =
+            admin_global_model_assign_to_providers_id(&request_context.request_path)
+        else {
+            return Ok(Some(
+                (
+                    http::StatusCode::NOT_FOUND,
+                    Json(json!({ "detail": "GlobalModel 不存在" })),
+                )
+                    .into_response(),
+            ));
+        };
+        let Some(request_body) = request_body else {
+            return Ok(Some(
+                (
+                    http::StatusCode::BAD_REQUEST,
+                    Json(json!({ "detail": "请求体不能为空" })),
+                )
+                    .into_response(),
+            ));
+        };
+        let payload =
+            match serde_json::from_slice::<AdminBatchAssignToProvidersRequest>(request_body) {
+                Ok(payload) => payload,
+                Err(_) => {
+                    return Ok(Some(
+                        (
+                            http::StatusCode::BAD_REQUEST,
+                            Json(json!({ "detail": "请求体必须是合法的 JSON 对象" })),
+                        )
+                            .into_response(),
+                    ));
+                }
+            };
+        let payload = match build_admin_assign_global_model_to_providers_payload(
+            state,
+            &global_model_id,
+            payload.provider_ids,
+            payload.create_models.unwrap_or(false),
+        )
+        .await
+        {
+            Ok(payload) => payload,
+            Err(detail) => {
+                return Ok(Some(
+                    (
+                        http::StatusCode::BAD_REQUEST,
+                        Json(json!({ "detail": detail })),
+                    )
+                        .into_response(),
+                ));
+            }
+        };
+        return Ok(Some(attach_admin_audit_response(
+            Json(payload).into_response(),
+            "admin_global_model_assigned_to_providers",
+            "assign_global_model_to_providers",
+            "global_model",
+            &global_model_id,
+        )));
+    }
+
+    if decision.route_family.as_deref() == Some("global_models_manage")
+        && decision.route_kind.as_deref() == Some("global_model_providers")
+        && request_context.request_method == http::Method::GET
+    {
+        if !state.has_global_model_data_reader() || !state.has_provider_catalog_data_reader() {
+            return Ok(Some(build_admin_global_models_data_unavailable_response()));
+        }
+        let Some(global_model_id) = admin_global_model_providers_id(&request_context.request_path)
+        else {
+            return Ok(Some(
+                (
+                    http::StatusCode::NOT_FOUND,
+                    Json(json!({ "detail": "GlobalModel 不存在" })),
+                )
+                    .into_response(),
+            ));
+        };
+        return Ok(Some(
+            match build_admin_global_model_providers_payload(state, &global_model_id).await {
+                Some(payload) => Json(payload).into_response(),
+                None => (
+                    http::StatusCode::NOT_FOUND,
+                    Json(json!({ "detail": format!("GlobalModel {global_model_id} 不存在") })),
+                )
+                    .into_response(),
+            },
+        ));
+    }
+
+    Ok(None)
+}

apps/aether-gateway/src/handlers/admin/model/mod.rs

@@ -0,0 +1,36 @@
+pub(crate) mod shared;
+
+mod catalog_routes;
+mod external_cache;
+mod global;
+mod global_models;
+mod payloads;
+mod routing;
+mod write;
+
+pub(crate) use self::catalog_routes::maybe_build_local_admin_model_catalog_response;
+pub(crate) use self::external_cache::{
+    clear_admin_external_models_cache, read_admin_external_models_cache,
+};
+pub(crate) use self::global::{
+    build_admin_global_model_payload, build_admin_global_model_providers_payload,
+    build_admin_global_model_response, build_admin_global_models_payload,
+    build_admin_model_catalog_payload, resolve_admin_global_model_by_id_or_err,
+};
+pub(crate) use self::global_models::maybe_build_local_admin_global_models_response;
+pub(crate) use self::payloads::{
+    admin_provider_model_effective_capability, admin_provider_model_effective_input_price,
+    admin_provider_model_effective_output_price, admin_provider_model_name_exists,
+    build_admin_provider_model_payload, build_admin_provider_model_response,
+    build_admin_provider_models_payload, normalize_optional_price,
+    normalize_required_trimmed_string,
+};
+pub(crate) use self::routing::{
+    build_admin_assign_global_model_to_providers_payload, build_admin_global_model_routing_payload,
+};
+pub(crate) use self::write::{
+    build_admin_batch_assign_global_models_payload, build_admin_global_model_create_record,
+    build_admin_global_model_update_record, build_admin_import_provider_models_payload,
+    build_admin_provider_available_source_models_payload, build_admin_provider_model_create_record,
+    build_admin_provider_model_update_record,
+};

apps/aether-gateway/src/handlers/admin/model/payloads.rs

@@ -0,0 +1,297 @@
+use crate::handlers::admin::shared::unix_secs_to_rfc3339;
+use crate::{AppState, GatewayError};
+use aether_data_contracts::repository::global_models::{
+    AdminProviderModelListQuery, StoredAdminProviderModel,
+};
+use serde_json::json;
+use std::time::{SystemTime, UNIX_EPOCH};
+
+pub(crate) fn model_tiered_pricing_first_tier_value(
+    tiered_pricing: Option<&serde_json::Value>,
+    field_name: &str,
+) -> Option<f64> {
+    tiered_pricing
+        .and_then(|value| value.get("tiers"))
+        .and_then(serde_json::Value::as_array)
+        .and_then(|tiers| tiers.first())
+        .and_then(|tier| tier.get(field_name))
+        .and_then(serde_json::Value::as_f64)
+}
+
+fn model_effective_capability(
+    explicit: Option<bool>,
+    global_model_config: Option<&serde_json::Value>,
+    config_key: &str,
+) -> bool {
+    explicit.unwrap_or_else(|| {
+        global_model_config
+            .and_then(|value| value.get(config_key))
+            .and_then(serde_json::Value::as_bool)
+            .unwrap_or(false)
+    })
+}
+
+fn merge_json_values(base: &mut serde_json::Value, overlay: serde_json::Value) {
+    match (base, overlay) {
+        (serde_json::Value::Object(base_map), serde_json::Value::Object(overlay_map)) => {
+            for (key, value) in overlay_map {
+                match base_map.get_mut(&key) {
+                    Some(existing) => merge_json_values(existing, value),
+                    None => {
+                        base_map.insert(key, value);
+                    }
+                }
+            }
+        }
+        (base, overlay) => *base = overlay,
+    }
+}
+
+fn merge_admin_provider_model_effective_config(
+    model: &StoredAdminProviderModel,
+) -> Option<serde_json::Value> {
+    let mut merged = match model.global_model_config.clone() {
+        Some(serde_json::Value::Object(map)) => serde_json::Value::Object(map),
+        Some(other) => other,
+        None => serde_json::Value::Object(serde_json::Map::new()),
+    };
+
+    if let Some(config) = model.config.clone() {
+        merge_json_values(&mut merged, config);
+    }
+
+    match merged {
+        serde_json::Value::Null => None,
+        serde_json::Value::Object(ref map) if map.is_empty() => None,
+        value => Some(value),
+    }
+}
+
+pub(crate) fn timestamp_or_now(value: Option<u64>, now_unix_secs: u64) -> serde_json::Value {
+    unix_secs_to_rfc3339(value.unwrap_or(now_unix_secs))
+        .map(serde_json::Value::String)
+        .unwrap_or(serde_json::Value::Null)
+}
+
+pub(crate) fn normalize_required_trimmed_string(
+    value: &str,
+    field_name: &str,
+) -> Result<String, String> {
+    let trimmed = value.trim();
+    if trimmed.is_empty() {
+        return Err(format!("{field_name} 不能为空"));
+    }
+    Ok(trimmed.to_string())
+}
+
+pub(crate) fn normalize_optional_price(
+    value: Option<f64>,
+    field_name: &str,
+) -> Result<Option<f64>, String> {
+    let Some(value) = value else {
+        return Ok(None);
+    };
+    if !value.is_finite() || value < 0.0 {
+        return Err(format!("{field_name} 必须是非负数"));
+    }
+    Ok(Some(value))
+}
+
+pub(crate) fn admin_provider_model_effective_input_price(
+    model: &StoredAdminProviderModel,
+) -> Option<f64> {
+    model_tiered_pricing_first_tier_value(model.tiered_pricing.as_ref(), "input_price_per_1m")
+        .or_else(|| {
+            model_tiered_pricing_first_tier_value(
+                model.global_model_default_tiered_pricing.as_ref(),
+                "input_price_per_1m",
+            )
+        })
+}
+
+pub(crate) fn admin_provider_model_effective_output_price(
+    model: &StoredAdminProviderModel,
+) -> Option<f64> {
+    model_tiered_pricing_first_tier_value(model.tiered_pricing.as_ref(), "output_price_per_1m")
+        .or_else(|| {
+            model_tiered_pricing_first_tier_value(
+                model.global_model_default_tiered_pricing.as_ref(),
+                "output_price_per_1m",
+            )
+        })
+}
+
+pub(crate) fn admin_provider_model_effective_capability(
+    model: &StoredAdminProviderModel,
+    capability: &str,
+) -> bool {
+    match capability {
+        "vision" => model_effective_capability(
+            model.supports_vision,
+            model.global_model_config.as_ref(),
+            "vision",
+        ),
+        "function_calling" => model_effective_capability(
+            model.supports_function_calling,
+            model.global_model_config.as_ref(),
+            "function_calling",
+        ),
+        "streaming" => model_effective_capability(
+            model.supports_streaming,
+            model.global_model_config.as_ref(),
+            "streaming",
+        ),
+        "extended_thinking" => model_effective_capability(
+            model.supports_extended_thinking,
+            model.global_model_config.as_ref(),
+            "extended_thinking",
+        ),
+        "image_generation" => model_effective_capability(
+            model.supports_image_generation,
+            model.global_model_config.as_ref(),
+            "image_generation",
+        ),
+        _ => false,
+    }
+}
+
+pub(crate) fn build_admin_provider_model_response(
+    model: &StoredAdminProviderModel,
+    now_unix_secs: u64,
+) -> serde_json::Value {
+    let effective_tiered_pricing = model
+        .tiered_pricing
+        .clone()
+        .or_else(|| model.global_model_default_tiered_pricing.clone());
+    let effective_config = merge_admin_provider_model_effective_config(model);
+
+    json!({
+        "id": &model.id,
+        "provider_id": &model.provider_id,
+        "global_model_id": &model.global_model_id,
+        "provider_model_name": &model.provider_model_name,
+        "provider_model_mappings": model.provider_model_mappings.clone(),
+        "price_per_request": model.price_per_request,
+        "tiered_pricing": model.tiered_pricing.clone(),
+        "effective_tiered_pricing": effective_tiered_pricing,
+        "effective_input_price": admin_provider_model_effective_input_price(model),
+        "effective_output_price": admin_provider_model_effective_output_price(model),
+        "effective_price_per_request": model
+            .price_per_request
+            .or(model.global_model_default_price_per_request),
+        "supports_vision": model.supports_vision,
+        "supports_function_calling": model.supports_function_calling,
+        "supports_streaming": model.supports_streaming,
+        "supports_extended_thinking": model.supports_extended_thinking,
+        "supports_image_generation": model.supports_image_generation,
+        "effective_supports_vision": admin_provider_model_effective_capability(model, "vision"),
+        "effective_supports_function_calling": admin_provider_model_effective_capability(
+            model,
+            "function_calling",
+        ),
+        "effective_supports_streaming": admin_provider_model_effective_capability(model, "streaming"),
+        "effective_supports_extended_thinking": admin_provider_model_effective_capability(
+            model,
+            "extended_thinking",
+        ),
+        "effective_supports_image_generation": admin_provider_model_effective_capability(
+            model,
+            "image_generation",
+        ),
+        "is_active": model.is_active,
+        "is_available": model.is_available,
+        "config": model.config.clone(),
+        "effective_config": effective_config,
+        "global_model_name": model.global_model_name.clone(),
+        "global_model_display_name": model.global_model_display_name.clone(),
+        "created_at": timestamp_or_now(model.created_at_unix_secs, now_unix_secs),
+        "updated_at": timestamp_or_now(model.updated_at_unix_secs, now_unix_secs),
+    })
+}
+
+pub(crate) async fn build_admin_provider_models_payload(
+    state: &AppState,
+    provider_id: &str,
+    skip: usize,
+    limit: usize,
+    is_active: Option<bool>,
+) -> Option<serde_json::Value> {
+    if !state.has_provider_catalog_data_reader() || !state.has_global_model_data_reader() {
+        return None;
+    }
+    let provider = state
+        .read_provider_catalog_providers_by_ids(&[provider_id.to_string()])
+        .await
+        .ok()?
+        .into_iter()
+        .next()?;
+    let mut models = state
+        .list_admin_provider_models(&AdminProviderModelListQuery {
+            provider_id: provider.id,
+            is_active,
+            offset: skip,
+            limit,
+        })
+        .await
+        .ok()?;
+    models.sort_by(|left, right| {
+        left.provider_model_name
+            .cmp(&right.provider_model_name)
+            .then_with(|| left.id.cmp(&right.id))
+    });
+    let now_unix_secs = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .ok()
+        .map(|duration| duration.as_secs())
+        .unwrap_or(0);
+    Some(serde_json::Value::Array(
+        models
+            .iter()
+            .map(|model| build_admin_provider_model_response(model, now_unix_secs))
+            .collect(),
+    ))
+}
+
+pub(crate) async fn build_admin_provider_model_payload(
+    state: &AppState,
+    provider_id: &str,
+    model_id: &str,
+) -> Option<serde_json::Value> {
+    if !state.has_global_model_data_reader() {
+        return None;
+    }
+    let model = state
+        .get_admin_provider_model(provider_id, model_id)
+        .await
+        .ok()??;
+    let now_unix_secs = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .ok()
+        .map(|duration| duration.as_secs())
+        .unwrap_or(0);
+    Some(build_admin_provider_model_response(&model, now_unix_secs))
+}
+
+pub(crate) async fn admin_provider_model_name_exists(
+    state: &AppState,
+    provider_id: &str,
+    provider_model_name: &str,
+    exclude_model_id: Option<&str>,
+) -> Result<bool, GatewayError> {
+    let target = provider_model_name.trim();
+    if target.is_empty() {
+        return Ok(false);
+    }
+    let models = state
+        .list_admin_provider_models(&AdminProviderModelListQuery {
+            provider_id: provider_id.to_string(),
+            is_active: None,
+            offset: 0,
+            limit: 10_000,
+        })
+        .await?;
+    Ok(models.into_iter().any(|model| {
+        model.provider_model_name == target
+            && exclude_model_id.is_none_or(|exclude| model.id != exclude)
+    }))
+}

apps/aether-gateway/src/handlers/admin/model/routing.rs

@@ -0,0 +1,348 @@
+use super::resolve_admin_global_model_by_id_or_err;
+use crate::handlers::admin::shared::{
+    json_string_list, masked_catalog_api_key, provider_catalog_key_supports_format,
+};
+use crate::AppState;
+use aether_data_contracts::repository::global_models::{
+    AdminProviderModelListQuery, UpsertAdminProviderModelRecord,
+};
+use aether_data_contracts::repository::provider_catalog::{
+    StoredProviderCatalogEndpoint, StoredProviderCatalogKey,
+};
+use aether_scheduler_core::{is_provider_key_circuit_open, provider_key_health_score};
+use serde_json::json;
+use std::collections::BTreeMap;
+use uuid::Uuid;
+
+pub(crate) async fn build_admin_global_model_routing_payload(
+    state: &AppState,
+    global_model_id: &str,
+) -> Option<serde_json::Value> {
+    if !state.has_global_model_data_reader() || !state.has_provider_catalog_data_reader() {
+        return None;
+    }
+    let global_model = state
+        .get_admin_global_model_by_id(global_model_id)
+        .await
+        .ok()??;
+    let provider_models = state
+        .list_admin_provider_models_by_global_model_id(global_model_id)
+        .await
+        .ok()?;
+    let provider_ids = provider_models
+        .iter()
+        .map(|model| model.provider_id.clone())
+        .collect::<Vec<_>>();
+    let providers = state
+        .read_provider_catalog_providers_by_ids(&provider_ids)
+        .await
+        .ok()?
+        .into_iter()
+        .map(|provider| (provider.id.clone(), provider))
+        .collect::<BTreeMap<_, _>>();
+    let endpoints = state
+        .list_provider_catalog_endpoints_by_provider_ids(&provider_ids)
+        .await
+        .ok()
+        .unwrap_or_default();
+    let keys = state
+        .list_provider_catalog_keys_by_provider_ids(&provider_ids)
+        .await
+        .ok()
+        .unwrap_or_default();
+    let mut endpoints_by_provider = BTreeMap::<String, Vec<StoredProviderCatalogEndpoint>>::new();
+    for endpoint in endpoints {
+        endpoints_by_provider
+            .entry(endpoint.provider_id.clone())
+            .or_default()
+            .push(endpoint);
+    }
+    let mut keys_by_provider = BTreeMap::<String, Vec<StoredProviderCatalogKey>>::new();
+    for key in keys {
+        keys_by_provider
+            .entry(key.provider_id.clone())
+            .or_default()
+            .push(key);
+    }
+
+    let scheduling_mode = state
+        .read_system_config_json_value("scheduling_mode")
+        .await
+        .ok()
+        .flatten()
+        .and_then(|value| value.as_str().map(ToOwned::to_owned))
+        .unwrap_or_else(|| "cache_affinity".to_string());
+    let priority_mode = state
+        .read_system_config_json_value("provider_priority_mode")
+        .await
+        .ok()
+        .flatten()
+        .and_then(|value| value.as_str().map(ToOwned::to_owned))
+        .unwrap_or_else(|| "provider".to_string());
+
+    let global_model_mappings = global_model
+        .config
+        .as_ref()
+        .and_then(|value| value.get("model_mappings"))
+        .and_then(serde_json::Value::as_array)
+        .map(|items| {
+            items
+                .iter()
+                .filter_map(serde_json::Value::as_str)
+                .map(ToOwned::to_owned)
+                .collect::<Vec<_>>()
+        })
+        .unwrap_or_default();
+
+    let mut providers_payload = Vec::new();
+    let mut all_keys_whitelist = Vec::new();
+    for model in provider_models {
+        let Some(provider) = providers.get(&model.provider_id) else {
+            continue;
+        };
+        let mut endpoint_payloads = Vec::new();
+        let mut active_endpoints = 0usize;
+        for endpoint in endpoints_by_provider
+            .get(&provider.id)
+            .cloned()
+            .unwrap_or_default()
+        {
+            if endpoint.is_active {
+                active_endpoints += 1;
+            }
+            let mut endpoint_keys = keys_by_provider
+                .get(&provider.id)
+                .cloned()
+                .unwrap_or_default()
+                .into_iter()
+                .filter(|key| provider_catalog_key_supports_format(key, &endpoint.api_format))
+                .collect::<Vec<_>>();
+            endpoint_keys.sort_by(|left, right| {
+                left.internal_priority
+                    .cmp(&right.internal_priority)
+                    .then_with(|| left.id.cmp(&right.id))
+            });
+            let key_payloads = endpoint_keys
+                .iter()
+                .map(|key| {
+                    let effective_rpm = key.learned_rpm_limit.or(key.rpm_limit);
+                    let is_adaptive = key.rpm_limit.is_none();
+                    let allowed_models = json_string_list(key.allowed_models.as_ref());
+                    let circuit_breaker_formats = key
+                        .circuit_breaker_by_format
+                        .as_ref()
+                        .and_then(serde_json::Value::as_object)
+                        .map(|entries| {
+                            entries
+                                .iter()
+                                .filter_map(|(api_format, value)| {
+                                    value.get("open")
+                                        .and_then(serde_json::Value::as_bool)
+                                        .filter(|is_open| *is_open)
+                                        .map(|_| api_format.clone())
+                                })
+                                .collect::<Vec<_>>()
+                        })
+                        .unwrap_or_default();
+                    let next_probe_at = key
+                        .circuit_breaker_by_format
+                        .as_ref()
+                        .and_then(serde_json::Value::as_object)
+                        .and_then(|entries| entries.get(&endpoint.api_format))
+                        .and_then(|value| value.get("next_probe_at"))
+                        .and_then(serde_json::Value::as_str)
+                        .map(ToOwned::to_owned);
+                    let payload = json!({
+                        "id": key.id,
+                        "name": key.name,
+                        "masked_key": masked_catalog_api_key(state, key),
+                        "is_active": key.is_active,
+                        "is_adaptive": is_adaptive,
+                        "effective_rpm": effective_rpm,
+                        "allowed_models": allowed_models,
+                        "health_score": provider_key_health_score(key, &endpoint.api_format),
+                        "circuit_breaker_open": is_provider_key_circuit_open(key, &endpoint.api_format),
+                        "circuit_breaker_formats": circuit_breaker_formats,
+                        "next_probe_at": next_probe_at,
+                    });
+                    all_keys_whitelist.push(json!({
+                        "key_id": &key.id,
+                        "key_name": &key.name,
+                        "masked_key": masked_catalog_api_key(state, key),
+                        "provider_id": &provider.id,
+                        "provider_name": &provider.name,
+                        "allowed_models": json_string_list(key.allowed_models.as_ref()),
+                    }));
+                    payload
+                })
+                .collect::<Vec<_>>();
+            endpoint_payloads.push(json!({
+                "id": endpoint.id,
+                "api_format": endpoint.api_format,
+                "base_url": endpoint.base_url,
+                "custom_path": endpoint.custom_path,
+                "is_active": endpoint.is_active,
+                "keys": key_payloads,
+                "total_keys": key_payloads.len(),
+                "active_keys": key_payloads.iter().filter(|value| value["is_active"] == json!(true)).count(),
+            }));
+        }
+        let model_mappings = model
+            .provider_model_mappings
+            .as_ref()
+            .and_then(serde_json::Value::as_array)
+            .cloned()
+            .unwrap_or_default();
+        providers_payload.push(json!({
+            "id": &provider.id,
+            "name": &provider.name,
+            "model_id": &model.id,
+            "provider_priority": provider.provider_priority,
+            "billing_type": provider.billing_type.clone(),
+            "monthly_quota_usd": provider.monthly_quota_usd,
+            "monthly_used_usd": provider.monthly_used_usd,
+            "is_active": provider.is_active,
+            "provider_model_name": &model.provider_model_name,
+            "model_mappings": model_mappings,
+            "model_is_active": model.is_active,
+            "endpoints": endpoint_payloads,
+            "total_endpoints": endpoint_payloads.len(),
+            "active_endpoints": active_endpoints,
+        }));
+    }
+    providers_payload.sort_by(|left, right| {
+        left.get("provider_priority")
+            .and_then(serde_json::Value::as_i64)
+            .cmp(
+                &right
+                    .get("provider_priority")
+                    .and_then(serde_json::Value::as_i64),
+            )
+            .then_with(|| {
+                left.get("name")
+                    .and_then(serde_json::Value::as_str)
+                    .cmp(&right.get("name").and_then(serde_json::Value::as_str))
+            })
+    });
+
+    let active_providers = providers_payload
+        .iter()
+        .filter(|provider| {
+            provider["is_active"] == json!(true) && provider["model_is_active"] == json!(true)
+        })
+        .count();
+    let total_providers = providers_payload.len();
+
+    Some(json!({
+        "global_model_id": &global_model.id,
+        "global_model_name": &global_model.name,
+        "display_name": &global_model.display_name,
+        "is_active": global_model.is_active,
+        "global_model_mappings": global_model_mappings,
+        "providers": providers_payload,
+        "total_providers": total_providers,
+        "active_providers": active_providers,
+        "scheduling_mode": scheduling_mode,
+        "priority_mode": priority_mode,
+        "all_keys_whitelist": all_keys_whitelist,
+    }))
+}
+
+pub(crate) async fn build_admin_assign_global_model_to_providers_payload(
+    state: &AppState,
+    global_model_id: &str,
+    provider_ids: Vec<String>,
+    create_models: bool,
+) -> Result<serde_json::Value, String> {
+    let global_model = resolve_admin_global_model_by_id_or_err(state, global_model_id).await?;
+    let providers = state
+        .read_provider_catalog_providers_by_ids(&provider_ids)
+        .await
+        .map_err(|err| format!("{err:?}"))?
+        .into_iter()
+        .map(|provider| (provider.id.clone(), provider))
+        .collect::<BTreeMap<_, _>>();
+
+    let mut success = Vec::new();
+    let mut errors = Vec::new();
+    for provider_id in provider_ids {
+        let provider_id = provider_id.trim().to_string();
+        if provider_id.is_empty() {
+            continue;
+        }
+        if !providers.contains_key(&provider_id) {
+            errors.push(json!({
+                "provider_id": provider_id,
+                "error": "Provider not found",
+            }));
+            continue;
+        }
+        let exists = state
+            .list_admin_provider_models(&AdminProviderModelListQuery {
+                provider_id: provider_id.clone(),
+                is_active: None,
+                offset: 0,
+                limit: 10_000,
+            })
+            .await
+            .map_err(|err| format!("{err:?}"))?
+            .into_iter()
+            .any(|model| model.global_model_id == global_model.id);
+        if exists {
+            errors.push(json!({
+                "provider_id": provider_id,
+                "error": "Model already exists",
+            }));
+            continue;
+        }
+        if !create_models {
+            errors.push(json!({
+                "provider_id": provider_id,
+                "error": "create_models disabled",
+            }));
+            continue;
+        }
+        let record = UpsertAdminProviderModelRecord::new(
+            Uuid::new_v4().to_string(),
+            provider_id.clone(),
+            global_model.id.clone(),
+            global_model.name.clone(),
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+            true,
+            true,
+            None,
+        )
+        .map_err(|err| err.to_string())?;
+        let created = state
+            .create_admin_provider_model(&record)
+            .await
+            .map_err(|err| format!("{err:?}"))?;
+        if let Some(created) = created {
+            success.push(json!({
+                "provider_id": provider_id,
+                "provider_model_id": created.id,
+                "global_model_id": global_model.id,
+            }));
+        } else {
+            errors.push(json!({
+                "provider_id": provider_id,
+                "error": "Create provider model failed",
+            }));
+        }
+    }
+    let total_success = success.len();
+    let total_errors = errors.len();
+    Ok(json!({
+        "success": success,
+        "errors": errors,
+        "total_success": total_success,
+        "total_errors": total_errors,
+    }))
+}

apps/aether-gateway/src/handlers/admin/model/shared/mod.rs

@@ -0,0 +1,5 @@
+mod paths;
+mod payloads;
+
+pub(crate) use self::paths::*;
+pub(crate) use self::payloads::*;

apps/aether-gateway/src/handlers/admin/model/shared/paths.rs

@@ -0,0 +1,46 @@
+pub(crate) fn is_admin_global_models_root(request_path: &str) -> bool {
+    matches!(
+        request_path,
+        "/api/admin/models/global" | "/api/admin/models/global/"
+    )
+}
+
+pub(crate) fn admin_global_model_id_from_path(request_path: &str) -> Option<String> {
+    let raw = request_path.strip_prefix("/api/admin/models/global/")?;
+    let normalized = raw.trim().trim_matches('/');
+    if normalized.is_empty()
+        || normalized.contains('/')
+        || normalized == "batch-delete"
+        || normalized.ends_with("/providers")
+        || normalized.ends_with("/assign-to-providers")
+        || normalized.ends_with("/routing")
+    {
+        None
+    } else {
+        Some(normalized.to_string())
+    }
+}
+
+pub(crate) fn admin_global_model_assign_to_providers_id(request_path: &str) -> Option<String> {
+    request_path
+        .strip_prefix("/api/admin/models/global/")?
+        .strip_suffix("/assign-to-providers")
+        .map(|value| value.trim().trim_matches('/').to_string())
+        .filter(|value| !value.is_empty() && !value.contains('/'))
+}
+
+pub(crate) fn admin_global_model_routing_id(request_path: &str) -> Option<String> {
+    request_path
+        .strip_prefix("/api/admin/models/global/")?
+        .strip_suffix("/routing")
+        .map(|value| value.trim().trim_matches('/').to_string())
+        .filter(|value| !value.is_empty() && !value.contains('/'))
+}
+
+pub(crate) fn admin_global_model_providers_id(request_path: &str) -> Option<String> {
+    request_path
+        .strip_prefix("/api/admin/models/global/")?
+        .strip_suffix("/providers")
+        .map(|value| value.trim().trim_matches('/').to_string())
+        .filter(|value| !value.is_empty() && !value.contains('/'))
+}

apps/aether-gateway/src/handlers/admin/model/shared/payloads.rs

@@ -0,0 +1,45 @@
+use serde::Deserialize;
+
+#[derive(Debug, Deserialize)]
+pub(crate) struct AdminGlobalModelCreateRequest {
+    pub(crate) name: String,
+    pub(crate) display_name: String,
+    #[serde(default)]
+    pub(crate) default_price_per_request: Option<f64>,
+    #[serde(default)]
+    pub(crate) default_tiered_pricing: Option<serde_json::Value>,
+    #[serde(default)]
+    pub(crate) supported_capabilities: Option<Vec<String>>,
+    #[serde(default)]
+    pub(crate) config: Option<serde_json::Value>,
+    #[serde(default)]
+    pub(crate) is_active: Option<bool>,
+}
+
+#[derive(Debug, Deserialize)]
+pub(crate) struct AdminGlobalModelUpdateRequest {
+    #[serde(default)]
+    pub(crate) display_name: Option<String>,
+    #[serde(default)]
+    pub(crate) is_active: Option<bool>,
+    #[serde(default)]
+    pub(crate) default_price_per_request: Option<f64>,
+    #[serde(default)]
+    pub(crate) default_tiered_pricing: Option<serde_json::Value>,
+    #[serde(default)]
+    pub(crate) supported_capabilities: Option<Vec<String>>,
+    #[serde(default)]
+    pub(crate) config: Option<serde_json::Value>,
+}
+
+#[derive(Debug, Deserialize)]
+pub(crate) struct AdminBatchDeleteIdsRequest {
+    pub(crate) ids: Vec<String>,
+}
+
+#[derive(Debug, Deserialize)]
+pub(crate) struct AdminBatchAssignToProvidersRequest {
+    pub(crate) provider_ids: Vec<String>,
+    #[serde(default)]
+    pub(crate) create_models: Option<bool>,
+}

apps/aether-gateway/src/handlers/admin/model/write.rs

@@ -0,0 +1,534 @@
+use super::{
+    admin_provider_model_effective_capability, admin_provider_model_effective_input_price,
+    admin_provider_model_effective_output_price, admin_provider_model_name_exists,
+    normalize_optional_price, normalize_required_trimmed_string,
+    resolve_admin_global_model_by_id_or_err,
+};
+use crate::handlers::admin::model::shared::{
+    AdminGlobalModelCreateRequest, AdminGlobalModelUpdateRequest,
+};
+use crate::handlers::admin::provider::shared::{
+    AdminImportProviderModelsRequest, AdminProviderModelCreateRequest,
+    AdminProviderModelUpdateRequest,
+};
+use crate::handlers::admin::shared::{
+    normalize_json_array, normalize_json_object, normalize_string_list,
+};
+use crate::AppState;
+use aether_data_contracts::repository::global_models::{
+    AdminProviderModelListQuery, CreateAdminGlobalModelRecord, StoredAdminGlobalModel,
+    StoredAdminProviderModel, UpdateAdminGlobalModelRecord, UpsertAdminProviderModelRecord,
+};
+use serde_json::json;
+use std::collections::{BTreeMap, BTreeSet};
+use uuid::Uuid;
+
+pub(crate) async fn build_admin_global_model_create_record(
+    state: &AppState,
+    payload: AdminGlobalModelCreateRequest,
+) -> Result<CreateAdminGlobalModelRecord, String> {
+    let name = normalize_required_trimmed_string(&payload.name, "name")?;
+    let display_name = normalize_required_trimmed_string(&payload.display_name, "display_name")?;
+    if state
+        .get_admin_global_model_by_name(&name)
+        .await
+        .map_err(|err| format!("{err:?}"))?
+        .is_some()
+    {
+        return Err(format!("GlobalModel '{name}' 已存在"));
+    }
+    let default_price_per_request = normalize_optional_price(
+        payload.default_price_per_request,
+        "default_price_per_request",
+    )?;
+    let default_tiered_pricing =
+        normalize_json_object(payload.default_tiered_pricing, "default_tiered_pricing")?;
+    let supported_capabilities =
+        normalize_string_list(payload.supported_capabilities).map(|value| json!(value));
+    let config = normalize_json_object(payload.config, "config")?;
+    CreateAdminGlobalModelRecord::new(
+        Uuid::new_v4().to_string(),
+        name,
+        display_name,
+        payload.is_active.unwrap_or(true),
+        default_price_per_request,
+        default_tiered_pricing,
+        supported_capabilities,
+        config,
+    )
+    .map_err(|err| err.to_string())
+}
+
+pub(crate) async fn build_admin_global_model_update_record(
+    _state: &AppState,
+    existing: &StoredAdminGlobalModel,
+    raw_payload: &serde_json::Map<String, serde_json::Value>,
+    payload: AdminGlobalModelUpdateRequest,
+) -> Result<UpdateAdminGlobalModelRecord, String> {
+    let display_name = if let Some(value) = raw_payload.get("display_name") {
+        let Some(display_name) = payload.display_name.as_deref() else {
+            return Err(if value.is_null() {
+                "display_name 不能为空".to_string()
+            } else {
+                "display_name 必须是字符串".to_string()
+            });
+        };
+        normalize_required_trimmed_string(display_name, "display_name")?
+    } else {
+        existing.display_name.clone()
+    };
+
+    let default_price_per_request = if raw_payload.contains_key("default_price_per_request") {
+        normalize_optional_price(
+            payload.default_price_per_request,
+            "default_price_per_request",
+        )?
+    } else {
+        existing.default_price_per_request
+    };
+
+    let default_tiered_pricing = if raw_payload.contains_key("default_tiered_pricing") {
+        normalize_json_object(payload.default_tiered_pricing, "default_tiered_pricing")?
+    } else {
+        existing.default_tiered_pricing.clone()
+    };
+
+    let supported_capabilities = if raw_payload.contains_key("supported_capabilities") {
+        normalize_string_list(payload.supported_capabilities).map(|value| json!(value))
+    } else {
+        existing.supported_capabilities.clone()
+    };
+
+    let config = if raw_payload.contains_key("config") {
+        normalize_json_object(payload.config, "config")?
+    } else {
+        existing.config.clone()
+    };
+
+    UpdateAdminGlobalModelRecord::new(
+        existing.id.clone(),
+        display_name,
+        payload.is_active.unwrap_or(existing.is_active),
+        default_price_per_request,
+        default_tiered_pricing,
+        supported_capabilities,
+        config,
+    )
+    .map_err(|err| err.to_string())
+}
+
+pub(crate) async fn build_admin_provider_model_create_record(
+    state: &AppState,
+    provider_id: &str,
+    payload: AdminProviderModelCreateRequest,
+) -> Result<UpsertAdminProviderModelRecord, String> {
+    let provider_model_name =
+        normalize_required_trimmed_string(&payload.provider_model_name, "provider_model_name")?;
+    if admin_provider_model_name_exists(state, provider_id, &provider_model_name, None)
+        .await
+        .map_err(|err| format!("{err:?}"))?
+    {
+        return Err(format!("模型 '{provider_model_name}' 已存在"));
+    }
+    let global_model_id =
+        normalize_required_trimmed_string(&payload.global_model_id, "global_model_id")?;
+    resolve_admin_global_model_by_id_or_err(state, &global_model_id).await?;
+    let price_per_request =
+        normalize_optional_price(payload.price_per_request, "price_per_request")?;
+    let tiered_pricing = normalize_json_object(payload.tiered_pricing, "tiered_pricing")?;
+    let provider_model_mappings =
+        normalize_json_array(payload.provider_model_mappings, "provider_model_mappings")?;
+    let config = normalize_json_object(payload.config, "config")?;
+    UpsertAdminProviderModelRecord::new(
+        Uuid::new_v4().to_string(),
+        provider_id.to_string(),
+        global_model_id,
+        provider_model_name,
+        provider_model_mappings,
+        price_per_request,
+        tiered_pricing,
+        payload.supports_vision,
+        payload.supports_function_calling,
+        payload.supports_streaming,
+        payload.supports_extended_thinking,
+        None,
+        payload.is_active.unwrap_or(true),
+        true,
+        config,
+    )
+    .map_err(|err| err.to_string())
+}
+
+pub(crate) async fn build_admin_provider_model_update_record(
+    state: &AppState,
+    existing: &StoredAdminProviderModel,
+    raw_payload: &serde_json::Map<String, serde_json::Value>,
+    payload: AdminProviderModelUpdateRequest,
+) -> Result<UpsertAdminProviderModelRecord, String> {
+    let provider_model_name = if let Some(value) = raw_payload.get("provider_model_name") {
+        let Some(name) = payload.provider_model_name.as_deref() else {
+            return Err(if value.is_null() {
+                "provider_model_name 不能为空".to_string()
+            } else {
+                "provider_model_name 必须是字符串".to_string()
+            });
+        };
+        let name = normalize_required_trimmed_string(name, "provider_model_name")?;
+        if admin_provider_model_name_exists(state, &existing.provider_id, &name, Some(&existing.id))
+            .await
+            .map_err(|err| format!("{err:?}"))?
+        {
+            return Err(format!("模型 '{name}' 已存在"));
+        }
+        name
+    } else {
+        existing.provider_model_name.clone()
+    };
+
+    let global_model_id = if let Some(value) = raw_payload.get("global_model_id") {
+        let Some(global_model_id) = payload.global_model_id.as_deref() else {
+            return Err(if value.is_null() {
+                "global_model_id 不能为空".to_string()
+            } else {
+                "global_model_id 必须是字符串".to_string()
+            });
+        };
+        let global_model_id =
+            normalize_required_trimmed_string(global_model_id, "global_model_id")?;
+        resolve_admin_global_model_by_id_or_err(state, &global_model_id).await?;
+        global_model_id
+    } else {
+        existing.global_model_id.clone()
+    };
+
+    let price_per_request = if raw_payload.contains_key("price_per_request") {
+        normalize_optional_price(payload.price_per_request, "price_per_request")?
+    } else {
+        existing.price_per_request
+    };
+    let tiered_pricing = if raw_payload.contains_key("tiered_pricing") {
+        normalize_json_object(payload.tiered_pricing, "tiered_pricing")?
+    } else {
+        existing.tiered_pricing.clone()
+    };
+    let provider_model_mappings = if raw_payload.contains_key("provider_model_mappings") {
+        normalize_json_array(payload.provider_model_mappings, "provider_model_mappings")?
+    } else {
+        existing.provider_model_mappings.clone()
+    };
+    let config = if raw_payload.contains_key("config") {
+        normalize_json_object(payload.config, "config")?
+    } else {
+        existing.config.clone()
+    };
+
+    UpsertAdminProviderModelRecord::new(
+        existing.id.clone(),
+        existing.provider_id.clone(),
+        global_model_id,
+        provider_model_name,
+        provider_model_mappings,
+        price_per_request,
+        tiered_pricing,
+        if raw_payload.contains_key("supports_vision") {
+            payload.supports_vision
+        } else {
+            existing.supports_vision
+        },
+        if raw_payload.contains_key("supports_function_calling") {
+            payload.supports_function_calling
+        } else {
+            existing.supports_function_calling
+        },
+        if raw_payload.contains_key("supports_streaming") {
+            payload.supports_streaming
+        } else {
+            existing.supports_streaming
+        },
+        if raw_payload.contains_key("supports_extended_thinking") {
+            payload.supports_extended_thinking
+        } else {
+            existing.supports_extended_thinking
+        },
+        existing.supports_image_generation,
+        payload.is_active.unwrap_or(existing.is_active),
+        payload.is_available.unwrap_or(existing.is_available),
+        config,
+    )
+    .map_err(|err| err.to_string())
+}
+
+pub(crate) async fn build_admin_provider_available_source_models_payload(
+    state: &AppState,
+    provider_id: &str,
+) -> Option<serde_json::Value> {
+    if !state.has_global_model_data_reader() || !state.has_provider_catalog_data_reader() {
+        return None;
+    }
+    let provider = state
+        .read_provider_catalog_providers_by_ids(&[provider_id.to_string()])
+        .await
+        .ok()?
+        .into_iter()
+        .next()?;
+    let models = state
+        .list_admin_provider_available_source_models(&provider.id)
+        .await
+        .ok()?;
+    let mut by_global_model = BTreeMap::<String, StoredAdminProviderModel>::new();
+    for model in models {
+        by_global_model
+            .entry(model.global_model_id.clone())
+            .or_insert(model);
+    }
+    let mut payload_models = by_global_model
+        .into_values()
+        .map(|model| {
+            json!({
+                "global_model_name": model.global_model_name,
+                "display_name": model.global_model_display_name,
+                "provider_model_name": model.provider_model_name,
+                "model_id": model.id,
+                "price": {
+                    "input_price_per_1m": admin_provider_model_effective_input_price(&model),
+                    "output_price_per_1m": admin_provider_model_effective_output_price(&model),
+                    "cache_creation_price_per_1m": serde_json::Value::Null,
+                    "cache_read_price_per_1m": serde_json::Value::Null,
+                    "price_per_request": model.price_per_request.or(model.global_model_default_price_per_request),
+                },
+                "capabilities": json!({
+                    "supports_vision": admin_provider_model_effective_capability(&model, "vision"),
+                    "supports_function_calling": admin_provider_model_effective_capability(&model, "function_calling"),
+                    "supports_streaming": admin_provider_model_effective_capability(&model, "streaming"),
+                }),
+                "is_active": model.is_active,
+            })
+        })
+        .collect::<Vec<_>>();
+    let total = payload_models.len();
+    payload_models.sort_by(|left, right| {
+        left.get("global_model_name")
+            .and_then(serde_json::Value::as_str)
+            .cmp(
+                &right
+                    .get("global_model_name")
+                    .and_then(serde_json::Value::as_str),
+            )
+    });
+    Some(json!({
+        "models": payload_models,
+        "total": total,
+    }))
+}
+
+pub(crate) async fn build_admin_batch_assign_global_models_payload(
+    state: &AppState,
+    provider_id: &str,
+    global_model_ids: Vec<String>,
+) -> Result<serde_json::Value, String> {
+    let existing_models = state
+        .list_admin_provider_models(&AdminProviderModelListQuery {
+            provider_id: provider_id.to_string(),
+            is_active: None,
+            offset: 0,
+            limit: 10_000,
+        })
+        .await
+        .map_err(|err| format!("{err:?}"))?;
+    let existing_global_model_ids = existing_models
+        .into_iter()
+        .map(|model| model.global_model_id)
+        .collect::<BTreeSet<_>>();
+
+    let mut success = Vec::new();
+    let mut errors = Vec::new();
+    for global_model_id in global_model_ids {
+        let global_model_id = global_model_id.trim().to_string();
+        if global_model_id.is_empty() {
+            continue;
+        }
+        let global_model =
+            match resolve_admin_global_model_by_id_or_err(state, &global_model_id).await {
+                Ok(model) => model,
+                Err(detail) => {
+                    errors.push(json!({
+                        "global_model_id": global_model_id,
+                        "error": detail,
+                    }));
+                    continue;
+                }
+            };
+        if existing_global_model_ids.contains(&global_model.id) {
+            errors.push(json!({
+                "global_model_id": global_model.id,
+                "error": "Model already exists",
+            }));
+            continue;
+        }
+        let record = UpsertAdminProviderModelRecord::new(
+            Uuid::new_v4().to_string(),
+            provider_id.to_string(),
+            global_model.id.clone(),
+            global_model.name.clone(),
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+            true,
+            true,
+            None,
+        )
+        .map_err(|err| err.to_string())?;
+        match state.create_admin_provider_model(&record).await {
+            Ok(Some(created)) => success.push(json!({
+                "global_model_id": global_model.id,
+                "global_model_name": global_model.name,
+                "provider_model_id": created.id,
+            })),
+            Ok(None) => errors.push(json!({
+                "global_model_id": global_model.id,
+                "error": "Create provider model failed",
+            })),
+            Err(err) => errors.push(json!({
+                "global_model_id": global_model.id,
+                "error": format!("{err:?}"),
+            })),
+        }
+    }
+    Ok(json!({
+        "success": success,
+        "errors": errors,
+    }))
+}
+
+pub(crate) async fn build_admin_import_provider_models_payload(
+    state: &AppState,
+    provider_id: &str,
+    payload: AdminImportProviderModelsRequest,
+) -> Result<serde_json::Value, String> {
+    let default_pricing = json!({
+        "tiers": [{
+            "up_to": null,
+            "input_price_per_1m": 0.0,
+            "output_price_per_1m": 0.0,
+        }]
+    });
+    let tiered_pricing = normalize_json_object(payload.tiered_pricing, "tiered_pricing")?;
+
+    let existing_models = state
+        .list_admin_provider_models(&AdminProviderModelListQuery {
+            provider_id: provider_id.to_string(),
+            is_active: None,
+            offset: 0,
+            limit: 10_000,
+        })
+        .await
+        .map_err(|err| format!("{err:?}"))?;
+    let mut existing_by_name = existing_models
+        .iter()
+        .map(|model| (model.provider_model_name.clone(), model.clone()))
+        .collect::<BTreeMap<_, _>>();
+
+    let mut success = Vec::new();
+    let mut errors = Vec::new();
+
+    for model_id in payload.model_ids {
+        let trimmed = model_id.trim();
+        if trimmed.is_empty() || trimmed.len() > 100 {
+            errors.push(json!({
+                "model_id": if trimmed.is_empty() { "<empty>" } else { trimmed },
+                "error": "Invalid model_id: must be 1-100 characters",
+            }));
+            continue;
+        }
+
+        if let Some(existing) = existing_by_name.get(trimmed) {
+            success.push(json!({
+                "model_id": trimmed,
+                "global_model_id": existing.global_model_id,
+                "global_model_name": existing.global_model_name,
+                "provider_model_id": existing.id,
+                "created_global_model": false,
+            }));
+            continue;
+        }
+
+        let mut created_global_model = false;
+        let global_model = if let Some(existing) = state
+            .get_admin_global_model_by_name(trimmed)
+            .await
+            .map_err(|err| format!("{err:?}"))?
+        {
+            existing
+        } else {
+            let created = state
+                .create_admin_global_model(
+                    &CreateAdminGlobalModelRecord::new(
+                        Uuid::new_v4().to_string(),
+                        trimmed.to_string(),
+                        trimmed.to_string(),
+                        true,
+                        payload.price_per_request,
+                        tiered_pricing
+                            .clone()
+                            .or_else(|| Some(default_pricing.clone())),
+                        None,
+                        None,
+                    )
+                    .map_err(|err| err.to_string())?,
+                )
+                .await
+                .map_err(|err| format!("{err:?}"))?;
+            let Some(created) = created else {
+                errors.push(json!({"model_id": trimmed, "error": "Create GlobalModel failed"}));
+                continue;
+            };
+            created_global_model = true;
+            created
+        };
+
+        let record = UpsertAdminProviderModelRecord::new(
+            Uuid::new_v4().to_string(),
+            provider_id.to_string(),
+            global_model.id.clone(),
+            trimmed.to_string(),
+            None,
+            payload.price_per_request,
+            tiered_pricing.clone(),
+            None,
+            None,
+            None,
+            None,
+            None,
+            true,
+            true,
+            None,
+        )
+        .map_err(|err| err.to_string())?;
+
+        match state.create_admin_provider_model(&record).await {
+            Ok(Some(created)) => {
+                existing_by_name.insert(trimmed.to_string(), created.clone());
+                success.push(json!({
+                    "model_id": trimmed,
+                    "global_model_id": global_model.id,
+                    "global_model_name": global_model.name,
+                    "provider_model_id": created.id,
+                    "created_global_model": created_global_model,
+                }));
+            }
+            Ok(None) => {
+                errors.push(json!({"model_id": trimmed, "error": "Create model failed"}));
+            }
+            Err(err) => {
+                errors.push(json!({"model_id": trimmed, "error": format!("{err:?}")}));
+            }
+        }
+    }
+
+    Ok(json!({ "success": success, "errors": errors }))
+}