refactor: 大规模模块拆分与重组，新增 aether-admin crate

- 新建独立 aether-admin crate 承载 admin 相关共享契约与纯辅助函数
- 拆分 ai_pipeline 下 kiro/private_envelope/conversion/planner 等大文件为子模块目录
- 重组 admin handlers 各业务域（billing/oauth/provider/system/users 等）为目录结构，移除 shared.rs/builders.rs 等反模式
- 移除 ai_pipeline runtime adapters 旧实现（claude/openai/gemini/kiro/vertex/antigravity 等），改由 provider transport 统一承载
- 移除 control_facade/execution_facade/auth_snapshot_facade 等冗余 facade 层
- 拆分 query/billing 与 query/monitoring 模块、state/runtime/payments 与 security 模块
- 扩展架构测试覆盖 admin_billing/admin_model/admin_users 等新模块
- 删除 docs/architecture/refactor-execution-plan.md 已完成的执行计划文档

apps/aether-gateway/src/handlers/admin/provider/models/assign_global.rs

@@ -1,9 +1,7 @@
-use super::write::build_admin_batch_assign_global_models_payload;
-use crate::control::GatewayControlDecision;
-use crate::control::GatewayPublicRequestContext;
 use crate::handlers::admin::provider::shared::paths::admin_provider_assign_global_models_path;
 use crate::handlers::admin::provider::shared::payloads::AdminBatchAssignGlobalModelsRequest;
-use crate::{AppState, GatewayError};
+use crate::handlers::admin::request::{AdminAppState, AdminRequestContext};
+use crate::GatewayError;
 use axum::{
     body::{Body, Bytes},
     http,
@@ -13,17 +11,15 @@ use axum::{
 use serde_json::json;
 
 pub(super) async fn maybe_handle(
-    state: &AppState,
-    request_context: &GatewayPublicRequestContext,
+    state: &AdminAppState<'_>,
+    request_context: &AdminRequestContext<'_>,
     request_body: Option<&Bytes>,
-    decision: &GatewayControlDecision,
 ) -> Result<Option<Response<Body>>, GatewayError> {
-    if decision.route_family.as_deref() == Some("provider_models_manage")
-        && decision.route_kind.as_deref() == Some("assign_global_models")
-        && request_context.request_method == http::Method::POST
+    if request_context.route_family() == Some("provider_models_manage")
+        && request_context.route_kind() == Some("assign_global_models")
+        && request_context.method() == http::Method::POST
     {
-        let Some(provider_id) =
-            admin_provider_assign_global_models_path(&request_context.request_path)
+        let Some(provider_id) = admin_provider_assign_global_models_path(request_context.path())
         else {
             return Ok(Some(
                 (
@@ -69,12 +65,9 @@ pub(super) async fn maybe_handle(
                     ));
                 }
             };
-        let payload = match build_admin_batch_assign_global_models_payload(
-            state,
-            &provider_id,
-            payload.global_model_ids,
-        )
-        .await
+        let payload = match state
+            .build_admin_batch_assign_global_models_payload(&provider_id, payload.global_model_ids)
+            .await
         {
             Ok(payload) => payload,
             Err(detail) => {

apps/aether-gateway/src/handlers/admin/provider/models/available_source.rs

@@ -1,8 +1,6 @@
-use super::write::build_admin_provider_available_source_models_payload;
-use crate::control::GatewayControlDecision;
-use crate::control::GatewayPublicRequestContext;
 use crate::handlers::admin::provider::shared::paths::admin_provider_available_source_models_path;
-use crate::{AppState, GatewayError};
+use crate::handlers::admin::request::{AdminAppState, AdminRequestContext};
+use crate::GatewayError;
 use axum::{
     body::{Body, Bytes},
     http,
@@ -12,17 +10,15 @@ use axum::{
 use serde_json::json;
 
 pub(super) async fn maybe_handle(
-    state: &AppState,
-    request_context: &GatewayPublicRequestContext,
+    state: &AdminAppState<'_>,
+    request_context: &AdminRequestContext<'_>,
     _request_body: Option<&Bytes>,
-    decision: &GatewayControlDecision,
 ) -> Result<Option<Response<Body>>, GatewayError> {
-    if decision.route_family.as_deref() == Some("provider_models_manage")
-        && decision.route_kind.as_deref() == Some("available_source_models")
-        && request_context.request_method == http::Method::GET
+    if request_context.route_family() == Some("provider_models_manage")
+        && request_context.route_kind() == Some("available_source_models")
+        && request_context.method() == http::Method::GET
     {
-        let Some(provider_id) =
-            admin_provider_available_source_models_path(&request_context.request_path)
+        let Some(provider_id) = admin_provider_available_source_models_path(request_context.path())
         else {
             return Ok(Some(
                 (
@@ -33,7 +29,10 @@ pub(super) async fn maybe_handle(
             ));
         };
         return Ok(Some(
-            match build_admin_provider_available_source_models_payload(state, &provider_id).await {
+            match state
+                .build_admin_provider_available_source_models_payload(&provider_id)
+                .await
+            {
                 Some(payload) => Json(payload).into_response(),
                 None => (
                     http::StatusCode::NOT_FOUND,

apps/aether-gateway/src/handlers/admin/provider/models/batch.rs

@@ -1,10 +1,8 @@
 use super::payloads::{admin_provider_model_name_exists, build_admin_provider_model_response};
-use super::write::build_admin_provider_model_create_record;
-use crate::control::GatewayControlDecision;
-use crate::control::GatewayPublicRequestContext;
 use crate::handlers::admin::provider::shared::paths::admin_provider_models_batch_path;
 use crate::handlers::admin::provider::shared::payloads::AdminProviderModelCreateRequest;
-use crate::{AppState, GatewayError};
+use crate::handlers::admin::request::{AdminAppState, AdminRequestContext};
+use crate::GatewayError;
 use axum::{
     body::{Body, Bytes},
     http,
@@ -16,18 +14,16 @@ use std::collections::BTreeSet;
 use std::time::{SystemTime, UNIX_EPOCH};
 
 pub(super) async fn maybe_handle(
-    state: &AppState,
-    request_context: &GatewayPublicRequestContext,
+    state: &AdminAppState<'_>,
+    request_context: &AdminRequestContext<'_>,
     request_body: Option<&Bytes>,
-    decision: &GatewayControlDecision,
 ) -> Result<Option<Response<Body>>, GatewayError> {
-    if decision.route_family.as_deref() == Some("provider_models_manage")
-        && decision.route_kind.as_deref() == Some("batch_create_provider_models")
-        && request_context.request_method == http::Method::POST
-        && request_context.request_path.ends_with("/models/batch")
+    if request_context.route_family() == Some("provider_models_manage")
+        && request_context.route_kind() == Some("batch_create_provider_models")
+        && request_context.method() == http::Method::POST
+        && request_context.path().ends_with("/models/batch")
     {
-        let Some(provider_id) = admin_provider_models_batch_path(&request_context.request_path)
-        else {
+        let Some(provider_id) = admin_provider_models_batch_path(request_context.path()) else {
             return Ok(Some(
                 (
                     http::StatusCode::NOT_FOUND,
@@ -98,12 +94,9 @@ pub(super) async fn maybe_handle(
             {
                 continue;
             }
-            let record = match build_admin_provider_model_create_record(
-                state,
-                &provider_id,
-                payload,
-            )
-            .await
+            let record = match state
+                .build_admin_provider_model_create_record(&provider_id, payload)
+                .await
             {
                 Ok(record) => record,
                 Err(detail) => {

apps/aether-gateway/src/handlers/admin/provider/models/create.rs

@@ -1,10 +1,8 @@
 use super::payloads::build_admin_provider_model_response;
-use super::write::build_admin_provider_model_create_record;
-use crate::control::GatewayControlDecision;
-use crate::control::GatewayPublicRequestContext;
 use crate::handlers::admin::provider::shared::paths::admin_provider_id_for_models_list;
 use crate::handlers::admin::provider::shared::payloads::AdminProviderModelCreateRequest;
-use crate::{AppState, GatewayError};
+use crate::handlers::admin::request::{AdminAppState, AdminRequestContext};
+use crate::GatewayError;
 use axum::{
     body::{Body, Bytes},
     http,
@@ -15,18 +13,16 @@ use serde_json::json;
 use std::time::{SystemTime, UNIX_EPOCH};
 
 pub(super) async fn maybe_handle(
-    state: &AppState,
-    request_context: &GatewayPublicRequestContext,
+    state: &AdminAppState<'_>,
+    request_context: &AdminRequestContext<'_>,
     request_body: Option<&Bytes>,
-    decision: &GatewayControlDecision,
 ) -> Result<Option<Response<Body>>, GatewayError> {
-    if decision.route_family.as_deref() == Some("provider_models_manage")
-        && decision.route_kind.as_deref() == Some("create_provider_model")
-        && request_context.request_method == http::Method::POST
-        && request_context.request_path.ends_with("/models")
+    if request_context.route_family() == Some("provider_models_manage")
+        && request_context.route_kind() == Some("create_provider_model")
+        && request_context.method() == http::Method::POST
+        && request_context.path().ends_with("/models")
     {
-        let Some(provider_id) = admin_provider_id_for_models_list(&request_context.request_path)
-        else {
+        let Some(provider_id) = admin_provider_id_for_models_list(request_context.path()) else {
             return Ok(Some(
                 (
                     http::StatusCode::NOT_FOUND,
@@ -71,19 +67,21 @@ pub(super) async fn maybe_handle(
                 ));
             }
         };
-        let record =
-            match build_admin_provider_model_create_record(state, &provider_id, payload).await {
-                Ok(record) => record,
-                Err(detail) => {
-                    return Ok(Some(
-                        (
-                            http::StatusCode::BAD_REQUEST,
-                            Json(json!({ "detail": detail })),
-                        )
-                            .into_response(),
-                    ));
-                }
-            };
+        let record = match state
+            .build_admin_provider_model_create_record(&provider_id, 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_provider_model(&record).await? {
                 Some(created) => {

apps/aether-gateway/src/handlers/admin/provider/models/delete.rs

@@ -1,7 +1,6 @@
-use crate::control::GatewayControlDecision;
-use crate::control::GatewayPublicRequestContext;
 use crate::handlers::admin::provider::shared::paths::admin_provider_model_route_parts;
-use crate::{AppState, GatewayError};
+use crate::handlers::admin::request::{AdminAppState, AdminRequestContext};
+use crate::GatewayError;
 use axum::{
     body::{Body, Bytes},
     http,
@@ -11,18 +10,17 @@ use axum::{
 use serde_json::json;
 
 pub(super) async fn maybe_handle(
-    state: &AppState,
-    request_context: &GatewayPublicRequestContext,
+    state: &AdminAppState<'_>,
+    request_context: &AdminRequestContext<'_>,
     _request_body: Option<&Bytes>,
-    decision: &GatewayControlDecision,
 ) -> Result<Option<Response<Body>>, GatewayError> {
-    if decision.route_family.as_deref() == Some("provider_models_manage")
-        && decision.route_kind.as_deref() == Some("delete_provider_model")
-        && request_context.request_method == http::Method::DELETE
-        && request_context.request_path.contains("/models/")
+    if request_context.route_family() == Some("provider_models_manage")
+        && request_context.route_kind() == Some("delete_provider_model")
+        && request_context.method() == http::Method::DELETE
+        && request_context.path().contains("/models/")
     {
         let Some((provider_id, model_id)) =
-            admin_provider_model_route_parts(&request_context.request_path)
+            admin_provider_model_route_parts(request_context.path())
         else {
             return Ok(Some(
                 (

apps/aether-gateway/src/handlers/admin/provider/models/detail.rs

@@ -1,8 +1,7 @@
 use super::payloads::build_admin_provider_model_payload;
-use crate::control::GatewayControlDecision;
-use crate::control::GatewayPublicRequestContext;
 use crate::handlers::admin::provider::shared::paths::admin_provider_model_route_parts;
-use crate::{AppState, GatewayError};
+use crate::handlers::admin::request::{AdminAppState, AdminRequestContext};
+use crate::GatewayError;
 use axum::{
     body::{Body, Bytes},
     http,
@@ -12,21 +11,18 @@ use axum::{
 use serde_json::json;
 
 pub(super) async fn maybe_handle(
-    state: &AppState,
-    request_context: &GatewayPublicRequestContext,
+    state: &AdminAppState<'_>,
+    request_context: &AdminRequestContext<'_>,
     _request_body: Option<&Bytes>,
-    decision: &GatewayControlDecision,
 ) -> Result<Option<Response<Body>>, GatewayError> {
-    if decision.route_family.as_deref() == Some("provider_models_manage")
-        && decision.route_kind.as_deref() == Some("get_provider_model")
-        && request_context.request_method == http::Method::GET
-        && request_context
-            .request_path
-            .starts_with("/api/admin/providers/")
-        && request_context.request_path.contains("/models/")
+    if request_context.route_family() == Some("provider_models_manage")
+        && request_context.route_kind() == Some("get_provider_model")
+        && request_context.method() == http::Method::GET
+        && request_context.path().starts_with("/api/admin/providers/")
+        && request_context.path().contains("/models/")
     {
         let Some((provider_id, model_id)) =
-            admin_provider_model_route_parts(&request_context.request_path)
+            admin_provider_model_route_parts(request_context.path())
         else {
             return Ok(Some(
                 (

apps/aether-gateway/src/handlers/admin/provider/models/import.rs

@@ -1,9 +1,7 @@
-use super::write::build_admin_import_provider_models_payload;
-use crate::control::GatewayControlDecision;
-use crate::control::GatewayPublicRequestContext;
 use crate::handlers::admin::provider::shared::paths::admin_provider_import_models_path;
 use crate::handlers::admin::provider::shared::payloads::AdminImportProviderModelsRequest;
-use crate::{AppState, GatewayError};
+use crate::handlers::admin::request::{AdminAppState, AdminRequestContext};
+use crate::GatewayError;
 use axum::{
     body::{Body, Bytes},
     http,
@@ -13,17 +11,15 @@ use axum::{
 use serde_json::json;
 
 pub(super) async fn maybe_handle(
-    state: &AppState,
-    request_context: &GatewayPublicRequestContext,
+    state: &AdminAppState<'_>,
+    request_context: &AdminRequestContext<'_>,
     request_body: Option<&Bytes>,
-    decision: &GatewayControlDecision,
 ) -> Result<Option<Response<Body>>, GatewayError> {
-    if decision.route_family.as_deref() == Some("provider_models_manage")
-        && decision.route_kind.as_deref() == Some("import_from_upstream")
-        && request_context.request_method == http::Method::POST
+    if request_context.route_family() == Some("provider_models_manage")
+        && request_context.route_kind() == Some("import_from_upstream")
+        && request_context.method() == http::Method::POST
     {
-        let Some(provider_id) = admin_provider_import_models_path(&request_context.request_path)
-        else {
+        let Some(provider_id) = admin_provider_import_models_path(request_context.path()) else {
             return Ok(Some(
                 (
                     http::StatusCode::NOT_FOUND,
@@ -68,19 +64,21 @@ pub(super) async fn maybe_handle(
                 ));
             }
         };
-        let payload =
-            match build_admin_import_provider_models_payload(state, &provider_id, payload).await {
-                Ok(payload) => payload,
-                Err(detail) => {
-                    return Ok(Some(
-                        (
-                            http::StatusCode::BAD_REQUEST,
-                            Json(json!({ "detail": detail })),
-                        )
-                            .into_response(),
-                    ));
-                }
-            };
+        let payload = match state
+            .build_admin_import_provider_models_payload(&provider_id, payload)
+            .await
+        {
+            Ok(payload) => payload,
+            Err(detail) => {
+                return Ok(Some(
+                    (
+                        http::StatusCode::BAD_REQUEST,
+                        Json(json!({ "detail": detail })),
+                    )
+                        .into_response(),
+                ));
+            }
+        };
         return Ok(Some(Json(payload).into_response()));
     }
 

apps/aether-gateway/src/handlers/admin/provider/models/list.rs

@@ -1,9 +1,8 @@
 use super::payloads::build_admin_provider_models_payload;
-use crate::control::GatewayControlDecision;
-use crate::control::GatewayPublicRequestContext;
 use crate::handlers::admin::provider::shared::paths::admin_provider_id_for_models_list;
+use crate::handlers::admin::request::{AdminAppState, AdminRequestContext};
 use crate::handlers::admin::shared::{query_param_optional_bool, query_param_value};
-use crate::{AppState, GatewayError};
+use crate::GatewayError;
 use axum::{
     body::{Body, Bytes},
     http,
@@ -13,21 +12,17 @@ use axum::{
 use serde_json::json;
 
 pub(super) async fn maybe_handle(
-    state: &AppState,
-    request_context: &GatewayPublicRequestContext,
+    state: &AdminAppState<'_>,
+    request_context: &AdminRequestContext<'_>,
     _request_body: Option<&Bytes>,
-    decision: &GatewayControlDecision,
 ) -> Result<Option<Response<Body>>, GatewayError> {
-    if decision.route_family.as_deref() == Some("provider_models_manage")
-        && decision.route_kind.as_deref() == Some("list_provider_models")
-        && request_context.request_method == http::Method::GET
-        && request_context
-            .request_path
-            .starts_with("/api/admin/providers/")
-        && request_context.request_path.ends_with("/models")
+    if request_context.route_family() == Some("provider_models_manage")
+        && request_context.route_kind() == Some("list_provider_models")
+        && request_context.method() == http::Method::GET
+        && request_context.path().starts_with("/api/admin/providers/")
+        && request_context.path().ends_with("/models")
     {
-        let Some(provider_id) = admin_provider_id_for_models_list(&request_context.request_path)
-        else {
+        let Some(provider_id) = admin_provider_id_for_models_list(request_context.path()) else {
             return Ok(Some(
                 (
                     http::StatusCode::NOT_FOUND,
@@ -36,15 +31,14 @@ pub(super) async fn maybe_handle(
                     .into_response(),
             ));
         };
-        let skip = query_param_value(request_context.request_query_string.as_deref(), "skip")
+        let skip = query_param_value(request_context.query_string(), "skip")
             .and_then(|value| value.parse::<usize>().ok())
             .unwrap_or(0);
-        let limit = query_param_value(request_context.request_query_string.as_deref(), "limit")
+        let limit = query_param_value(request_context.query_string(), "limit")
             .and_then(|value| value.parse::<usize>().ok())
             .filter(|value| *value > 0 && *value <= 500)
             .unwrap_or(100);
-        let is_active =
-            query_param_optional_bool(request_context.request_query_string.as_deref(), "is_active");
+        let is_active = query_param_optional_bool(request_context.query_string(), "is_active");
         return Ok(Some(
             match build_admin_provider_models_payload(state, &provider_id, skip, limit, is_active)
                 .await

apps/aether-gateway/src/handlers/admin/provider/models/mod.rs

@@ -1,6 +1,5 @@
-use crate::control::GatewayControlDecision;
-use crate::control::GatewayPublicRequestContext;
-use crate::{AppState, GatewayError};
+use crate::handlers::admin::request::{AdminAppState, AdminRequestContext};
+use crate::GatewayError;
 use axum::body::{Body, Bytes};
 use axum::http::Response;
 
@@ -14,68 +13,53 @@ mod import;
 mod list;
 mod payloads;
 mod update;
-mod write;
 
 pub(crate) async fn maybe_build_local_admin_provider_models_response(
-    state: &AppState,
-    request_context: &GatewayPublicRequestContext,
+    state: &AdminAppState<'_>,
+    request_context: &AdminRequestContext<'_>,
     request_body: Option<&Bytes>,
 ) -> Result<Option<Response<Body>>, GatewayError> {
-    let Some(decision) = request_context.control_decision.as_ref() else {
+    if request_context.route_family() != Some("provider_models_manage") {
         return Ok(None);
-    };
+    }
+
+    if let Some(response) = list::maybe_handle(state, request_context, request_body).await? {
+        return Ok(Some(response));
+    }
+
+    if let Some(response) = detail::maybe_handle(state, request_context, request_body).await? {
+        return Ok(Some(response));
+    }
+
+    if let Some(response) = create::maybe_handle(state, request_context, request_body).await? {
+        return Ok(Some(response));
+    }
+
+    if let Some(response) = update::maybe_handle(state, request_context, request_body).await? {
+        return Ok(Some(response));
+    }
+
+    if let Some(response) = delete::maybe_handle(state, request_context, request_body).await? {
+        return Ok(Some(response));
+    }
+
+    if let Some(response) = batch::maybe_handle(state, request_context, request_body).await? {
+        return Ok(Some(response));
+    }
 
     if let Some(response) =
-        list::maybe_handle(state, request_context, request_body, decision).await?
+        available_source::maybe_handle(state, request_context, request_body).await?
     {
         return Ok(Some(response));
     }
 
     if let Some(response) =
-        detail::maybe_handle(state, request_context, request_body, decision).await?
+        assign_global::maybe_handle(state, request_context, request_body).await?
     {
         return Ok(Some(response));
     }
 
-    if let Some(response) =
-        create::maybe_handle(state, request_context, request_body, decision).await?
-    {
-        return Ok(Some(response));
-    }
-
-    if let Some(response) =
-        update::maybe_handle(state, request_context, request_body, decision).await?
-    {
-        return Ok(Some(response));
-    }
-
-    if let Some(response) =
-        delete::maybe_handle(state, request_context, request_body, decision).await?
-    {
-        return Ok(Some(response));
-    }
-
-    if let Some(response) =
-        batch::maybe_handle(state, request_context, request_body, decision).await?
-    {
-        return Ok(Some(response));
-    }
-
-    if let Some(response) =
-        available_source::maybe_handle(state, request_context, request_body, decision).await?
-    {
-        return Ok(Some(response));
-    }
-
-    if let Some(response) =
-        assign_global::maybe_handle(state, request_context, request_body, decision).await?
-    {
-        return Ok(Some(response));
-    }
-
-    if let Some(response) =
-        import::maybe_handle(state, request_context, request_body, decision).await?
-    {
+    if let Some(response) = import::maybe_handle(state, request_context, request_body).await? {
         return Ok(Some(response));
     }
 

apps/aether-gateway/src/handlers/admin/provider/models/payloads.rs

@@ -1,192 +1,39 @@
-use crate::handlers::admin::shared::unix_secs_to_rfc3339;
-use crate::{AppState, GatewayError};
+use crate::handlers::admin::request::AdminAppState;
+use crate::GatewayError;
+use aether_admin::provider::models as admin_provider_models_pure;
 use aether_data_contracts::repository::global_models::{
     AdminProviderModelListQuery, StoredAdminProviderModel,
 };
-use serde_json::json;
 use std::time::{SystemTime, UNIX_EPOCH};
 
-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),
-    }
-}
-
-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(super) 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",
-            )
-        })
+    admin_provider_models_pure::admin_provider_model_effective_input_price(model)
 }
 
 pub(super) 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",
-            )
-        })
+    admin_provider_models_pure::admin_provider_model_effective_output_price(model)
 }
 
 pub(super) 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,
-    }
+    admin_provider_models_pure::admin_provider_model_effective_capability(model, capability)
 }
 
 pub(super) 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),
-    })
+    admin_provider_models_pure::build_admin_provider_model_response(model, now_unix_secs)
 }
 
 pub(super) async fn build_admin_provider_models_payload(
-    state: &AppState,
+    state: &AdminAppState<'_>,
     provider_id: &str,
     skip: usize,
     limit: usize,
@@ -229,7 +76,7 @@ pub(super) async fn build_admin_provider_models_payload(
 }
 
 pub(super) async fn build_admin_provider_model_payload(
-    state: &AppState,
+    state: &AdminAppState<'_>,
     provider_id: &str,
     model_id: &str,
 ) -> Option<serde_json::Value> {
@@ -249,25 +96,12 @@ pub(super) async fn build_admin_provider_model_payload(
 }
 
 pub(super) async fn admin_provider_model_name_exists(
-    state: &AppState,
+    state: &AdminAppState<'_>,
     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)
-    }))
+    state
+        .admin_provider_model_name_exists(provider_id, provider_model_name, exclude_model_id)
+        .await
 }

apps/aether-gateway/src/handlers/admin/provider/models/update.rs

@@ -1,10 +1,8 @@
 use super::payloads::build_admin_provider_model_response;
-use super::write::build_admin_provider_model_update_record;
-use crate::control::GatewayControlDecision;
-use crate::control::GatewayPublicRequestContext;
 use crate::handlers::admin::provider::shared::paths::admin_provider_model_route_parts;
 use crate::handlers::admin::provider::shared::payloads::AdminProviderModelUpdateRequest;
-use crate::{AppState, GatewayError};
+use crate::handlers::admin::request::{AdminAppState, AdminRequestContext};
+use crate::GatewayError;
 use axum::{
     body::{Body, Bytes},
     http,
@@ -15,18 +13,17 @@ use serde_json::json;
 use std::time::{SystemTime, UNIX_EPOCH};
 
 pub(super) async fn maybe_handle(
-    state: &AppState,
-    request_context: &GatewayPublicRequestContext,
+    state: &AdminAppState<'_>,
+    request_context: &AdminRequestContext<'_>,
     request_body: Option<&Bytes>,
-    decision: &GatewayControlDecision,
 ) -> Result<Option<Response<Body>>, GatewayError> {
-    if decision.route_family.as_deref() == Some("provider_models_manage")
-        && decision.route_kind.as_deref() == Some("update_provider_model")
-        && request_context.request_method == http::Method::PATCH
-        && request_context.request_path.contains("/models/")
+    if request_context.route_family() == Some("provider_models_manage")
+        && request_context.route_kind() == Some("update_provider_model")
+        && request_context.method() == http::Method::PATCH
+        && request_context.path().contains("/models/")
     {
         let Some((provider_id, model_id)) =
-            admin_provider_model_route_parts(&request_context.request_path)
+            admin_provider_model_route_parts(request_context.path())
         else {
             return Ok(Some(
                 (
@@ -90,21 +87,21 @@ pub(super) async fn maybe_handle(
                 ));
             }
         };
-        let record =
-            match build_admin_provider_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(),
-                    ));
-                }
-            };
+        let record = match state
+            .build_admin_provider_model_update_record(&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_provider_model(&record).await? {
                 Some(updated) => {

apps/aether-gateway/src/handlers/admin/provider/models/write.rs

@@ -1,472 +0,0 @@
-use super::payloads::{
-    admin_provider_model_effective_capability, admin_provider_model_effective_input_price,
-    admin_provider_model_effective_output_price, admin_provider_model_name_exists,
-};
-use crate::handlers::admin::provider::shared::payloads::{
-    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, UpdateAdminGlobalModelRecord,
-    UpsertAdminProviderModelRecord,
-};
-use serde_json::json;
-use std::collections::{BTreeMap, BTreeSet};
-use uuid::Uuid;
-
-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())
-}
-
-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))
-}
-
-async fn resolve_admin_global_model_by_id_or_err(
-    state: &AppState,
-    global_model_id: &str,
-) -> Result<aether_data_contracts::repository::global_models::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} 不存在"))
-}
-
-pub(super) 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(super) async fn build_admin_provider_model_update_record(
-    state: &AppState,
-    existing: &aether_data_contracts::repository::global_models::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(super) 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,
-        aether_data_contracts::repository::global_models::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(super) 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(super) 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 provider model failed",
-            })),
-            Err(err) => errors.push(json!({
-                "model_id": trimmed,
-                "error": format!("{err:?}"),
-            })),
-        }
-    }
-
-    Ok(json!({
-        "success": success,
-        "errors": errors,
-    }))
-}