fix: preserve legacy admin config imports

apps/aether-gateway/src/handlers/admin/request/system/import.rs

@@ -148,7 +148,14 @@ fn remap_import_proxy(
 }
 
 fn normalize_import_endpoint_format(value: &str) -> Result<String, String> {
-    admin_endpoint_signature_parts(value)
+    let normalized = match value.trim().to_ascii_lowercase().as_str() {
+        "openai:cli" => "openai:responses",
+        "openai:compact" => "openai:responses:compact",
+        "claude:chat" | "claude:cli" => "claude:messages",
+        "gemini:chat" | "gemini:cli" => "gemini:generate_content",
+        _ => value.trim(),
+    };
+    admin_endpoint_signature_parts(normalized)
         .map(|(signature, _, _)| signature.to_string())
         .ok_or_else(|| format!("无效的 api_format: {value}"))
 }
@@ -1173,7 +1180,7 @@ impl<'a> AdminAppState<'a> {
                         }
                         AdminImportMergeMode::Overwrite => {
                             let Some((normalized_signature, api_family, endpoint_kind)) =
-                                admin_endpoint_signature_parts(&imported_endpoint.api_format)
+                                admin_endpoint_signature_parts(&normalized_api_format)
                             else {
                                 return Ok(Err(invalid_request(format!(
                                     "无效的 api_format: {}",
@@ -1246,7 +1253,7 @@ impl<'a> AdminAppState<'a> {
                 }
 
                 let Some((normalized_signature, api_family, endpoint_kind)) =
-                    admin_endpoint_signature_parts(&imported_endpoint.api_format)
+                    admin_endpoint_signature_parts(&normalized_api_format)
                 else {
                     return Ok(Err(invalid_request(format!(
                         "无效的 api_format: {}",
@@ -2832,7 +2839,9 @@ mod tests {
     use super::{
         imported_optional_bool, imported_optional_f64, imported_optional_i32,
         imported_optional_u64, imported_rfc3339_to_unix_secs, imported_string_list_from_value,
+        normalize_import_endpoint_format, normalize_import_key_formats,
         normalize_imported_wallet_target, validate_imported_system_users_export_version,
+        ImportedProviderKey,
     };
 
     #[test]
@@ -2849,6 +2858,59 @@ mod tests {
         );
     }
 
+    #[test]
+    fn config_import_normalizes_python_cli_api_format_aliases() {
+        for (raw, expected) in [
+            ("openai:cli", "openai:responses"),
+            ("openai:compact", "openai:responses:compact"),
+            ("claude:chat", "claude:messages"),
+            ("claude:cli", "claude:messages"),
+            ("gemini:chat", "gemini:generate_content"),
+            ("gemini:cli", "gemini:generate_content"),
+        ] {
+            assert_eq!(normalize_import_endpoint_format(raw).unwrap(), expected);
+        }
+    }
+
+    #[test]
+    fn config_import_normalizes_key_formats_against_imported_endpoint_aliases() {
+        let endpoint_formats = ["claude:messages", "openai:responses:compact"]
+            .into_iter()
+            .map(ToOwned::to_owned)
+            .collect();
+        let item = ImportedProviderKey {
+            api_key: None,
+            auth_type: None,
+            auth_config: None,
+            name: None,
+            note: None,
+            api_formats: Some(vec!["claude:cli".to_string(), "openai:compact".to_string()]),
+            supported_endpoints: None,
+            rate_multipliers: None,
+            internal_priority: None,
+            global_priority_by_format: None,
+            auth_type_by_format: None,
+            allow_auth_channel_mismatch_formats: None,
+            rpm_limit: None,
+            allowed_models: None,
+            capabilities: None,
+            cache_ttl_minutes: None,
+            max_probe_interval_minutes: None,
+            auto_fetch_models: None,
+            locked_models: None,
+            model_include_patterns: None,
+            model_exclude_patterns: None,
+            is_active: true,
+            proxy: None,
+            fingerprint: None,
+        };
+
+        let (formats, missing) = normalize_import_key_formats(&item, &endpoint_formats);
+
+        assert_eq!(formats, vec!["claude:messages", "openai:responses:compact"]);
+        assert!(missing.is_empty());
+    }
+
     #[test]
     fn import_handles_legacy_string_scalars() {
         assert_eq!(

apps/aether-gateway/src/tests/control/admin/system_import.rs

@@ -1,5 +1,6 @@
 use std::sync::{Arc, Mutex};
 
+use aether_contracts::ExecutionPlan;
 use aether_crypto::{
     decrypt_python_fernet_ciphertext, encrypt_python_fernet_plaintext, DEVELOPMENT_ENCRYPTION_KEY,
 };
@@ -22,27 +23,24 @@ use aether_data_contracts::repository::provider_catalog::ProviderCatalogReadRepo
 use axum::body::{Body, Bytes};
 use axum::http::HeaderMap;
 use axum::routing::{any, post};
-use axum::{extract::Request, Router};
+use axum::{extract::Request, Json, Router};
 use http::StatusCode;
 use serde_json::{json, Value};
 
 use super::super::helpers::{sample_endpoint, sample_key, sample_provider};
-use super::super::{build_router_with_state, start_server, AppState};
+use super::super::{
+    build_router_with_state, build_state_with_execution_runtime_override, start_server, AppState,
+};
 use crate::constants::{
     GATEWAY_HEADER, TRUSTED_ADMIN_SESSION_ID_HEADER, TRUSTED_ADMIN_USER_ID_HEADER,
     TRUSTED_ADMIN_USER_ROLE_HEADER,
 };
 use crate::data::GatewayDataState;
 
-fn build_empty_admin_system_data_state() -> GatewayDataState {
+fn build_admin_system_data_state_with_repositories(
-    let provider_catalog_repository = Arc::new(InMemoryProviderCatalogReadRepository::seed(
+    provider_catalog_repository: Arc<InMemoryProviderCatalogReadRepository>,
-        Vec::new(),
+    global_model_repository: Arc<InMemoryGlobalModelReadRepository>,
-        Vec::new(),
+) -> GatewayDataState {
-        Vec::new(),
-    ));
-    let global_model_repository = Arc::new(InMemoryGlobalModelReadRepository::seed(Vec::<
-        StoredPublicGlobalModel,
-    >::new()));
     let auth_module_repository = Arc::new(InMemoryAuthModuleReadRepository::seed(
         Vec::<StoredOAuthProviderModuleConfig>::new(),
         None,
@@ -59,6 +57,21 @@ fn build_empty_admin_system_data_state() -> GatewayDataState {
         .with_encryption_key_for_tests(DEVELOPMENT_ENCRYPTION_KEY)
 }
 
+fn build_empty_admin_system_data_state() -> GatewayDataState {
+    let provider_catalog_repository = Arc::new(InMemoryProviderCatalogReadRepository::seed(
+        Vec::new(),
+        Vec::new(),
+        Vec::new(),
+    ));
+    let global_model_repository = Arc::new(InMemoryGlobalModelReadRepository::seed(Vec::<
+        StoredPublicGlobalModel,
+    >::new()));
+    build_admin_system_data_state_with_repositories(
+        provider_catalog_repository,
+        global_model_repository,
+    )
+}
+
 fn sample_system_import_payload() -> Value {
     json!({
         "version": "2.2",
@@ -503,7 +516,232 @@ async fn gateway_returns_503_for_admin_system_config_import_when_local_data_is_u
 }
 
 #[tokio::test]
-async fn gateway_rejects_legacy_admin_system_config_import_versions() {
+async fn gateway_imports_legacy_admin_system_config_versions_and_model_test_succeeds() {
+    for (
+        fixture_name,
+        expected_provider_name,
+        expected_model_name,
+        expected_api_key,
+        expected_base_url,
+    ) in [
+        (
+            "v20",
+            "legacy-provider-v20",
+            "legacy-gpt-5-v20",
+            "sk-legacy-v20",
+            "https://legacy-v20.example.com/v1",
+        ),
+        (
+            "v21",
+            "legacy-provider-v21",
+            "legacy-gpt-5-v21",
+            "sk-legacy-v21",
+            "https://legacy-v21.example.com/v1",
+        ),
+    ] {
+        assert_legacy_admin_system_config_import_model_test_succeeds(
+            fixture_name,
+            expected_provider_name,
+            expected_model_name,
+            expected_api_key,
+            expected_base_url,
+        )
+        .await;
+    }
+}
+
+async fn assert_legacy_admin_system_config_import_model_test_succeeds(
+    fixture_name: &str,
+    expected_provider_name: &str,
+    expected_model_name: &str,
+    expected_api_key: &str,
+    expected_base_url: &str,
+) {
+    let execution_runtime_hits = Arc::new(Mutex::new(0usize));
+    let execution_runtime_hits_clone = Arc::clone(&execution_runtime_hits);
+    let expected_base_url_for_runtime = expected_base_url.to_string();
+    let expected_model_for_runtime = expected_model_name.to_string();
+    let expected_bearer_for_runtime = format!("Bearer {expected_api_key}");
+    let execution_runtime = Router::new().route(
+        "/v1/execute/sync",
+        any(move |Json(plan): Json<ExecutionPlan>| {
+            let execution_runtime_hits_inner = Arc::clone(&execution_runtime_hits_clone);
+            let expected_base_url = expected_base_url_for_runtime.clone();
+            let expected_model = expected_model_for_runtime.clone();
+            let expected_bearer = expected_bearer_for_runtime.clone();
+            async move {
+                *execution_runtime_hits_inner
+                    .lock()
+                    .expect("mutex should lock") += 1;
+                assert_eq!(plan.provider_api_format, "openai:chat");
+                assert!(
+                    plan.url.starts_with(expected_base_url.as_str()),
+                    "unexpected execution url: {}",
+                    plan.url
+                );
+                assert_eq!(plan.model_name.as_deref(), Some(expected_model.as_str()));
+                assert_eq!(
+                    plan.headers.get("authorization").map(String::as_str),
+                    Some(expected_bearer.as_str())
+                );
+                assert_eq!(
+                    plan.body
+                        .json_body
+                        .as_ref()
+                        .and_then(|body| body.get("model"))
+                        .and_then(Value::as_str),
+                    Some(expected_model.as_str())
+                );
+                Json(json!({
+                    "request_id": plan.request_id,
+                    "candidate_id": plan.candidate_id,
+                    "status_code": 200,
+                    "headers": {
+                        "content-type": "application/json"
+                    },
+                    "body": {
+                        "json_body": {
+                            "id": "chatcmpl-legacy-import",
+                            "object": "chat.completion",
+                            "choices": [{
+                                "message": {
+                                    "role": "assistant",
+                                    "content": "Hello from imported provider"
+                                }
+                            }]
+                        }
+                    },
+                    "telemetry": {
+                        "elapsed_ms": 17
+                    }
+                }))
+            }
+        }),
+    );
+
+    let (execution_runtime_url, execution_runtime_handle) = start_server(execution_runtime).await;
+    let provider_catalog_repository = Arc::new(InMemoryProviderCatalogReadRepository::seed(
+        Vec::new(),
+        Vec::new(),
+        Vec::new(),
+    ));
+    let global_model_repository = Arc::new(InMemoryGlobalModelReadRepository::seed(Vec::<
+        StoredPublicGlobalModel,
+    >::new()));
+    let data_state = build_admin_system_data_state_with_repositories(
+        Arc::clone(&provider_catalog_repository),
+        Arc::clone(&global_model_repository),
+    );
+    let gateway = build_router_with_state(
+        build_state_with_execution_runtime_override(execution_runtime_url)
+            .with_data_state_for_tests(data_state),
+    );
+    let (gateway_url, gateway_handle) = start_server(gateway).await;
+    let client = reqwest::Client::new();
+
+    let import_response = client
+        .post(format!("{gateway_url}/api/admin/system/config/import"))
+        .header(GATEWAY_HEADER, "rust-phase3b")
+        .header(TRUSTED_ADMIN_USER_ID_HEADER, "admin-user-123")
+        .header(TRUSTED_ADMIN_USER_ROLE_HEADER, "admin")
+        .header(TRUSTED_ADMIN_SESSION_ID_HEADER, "session-123")
+        .json(&fixture_system_import_payload(fixture_name))
+        .send()
+        .await
+        .expect("request should succeed");
+
+    let import_status = import_response.status();
+    let import_payload: Value = import_response
+        .json()
+        .await
+        .expect("json body should parse");
+    assert_eq!(import_status, StatusCode::OK, "payload={import_payload}");
+    assert_eq!(import_payload["stats"]["providers"]["created"], json!(1));
+    assert_eq!(import_payload["stats"]["endpoints"]["created"], json!(1));
+    assert_eq!(import_payload["stats"]["keys"]["created"], json!(1));
+    assert_eq!(import_payload["stats"]["models"]["created"], json!(1));
+
+    let providers = provider_catalog_repository
+        .list_providers(false)
+        .await
+        .expect("providers should load");
+    assert_eq!(providers.len(), 1);
+    assert_eq!(providers[0].name, expected_provider_name);
+    let provider_id = providers[0].id.clone();
+    let provider_ids = vec![provider_id.clone()];
+    let endpoints = provider_catalog_repository
+        .list_endpoints_by_provider_ids(&provider_ids)
+        .await
+        .expect("endpoints should load");
+    assert_eq!(endpoints.len(), 1);
+    assert_eq!(endpoints[0].base_url, expected_base_url);
+    let endpoint_id = endpoints[0].id.clone();
+
+    let keys = provider_catalog_repository
+        .list_keys_by_provider_ids(&provider_ids)
+        .await
+        .expect("keys should load");
+    assert_eq!(keys.len(), 1);
+    assert_eq!(
+        decrypt_python_fernet_ciphertext(
+            DEVELOPMENT_ENCRYPTION_KEY,
+            keys[0]
+                .encrypted_api_key
+                .as_deref()
+                .expect("api key should be present"),
+        )
+        .expect("api key should decrypt"),
+        expected_api_key
+    );
+
+    let provider_models = global_model_repository
+        .list_admin_provider_models(&AdminProviderModelListQuery {
+            provider_id: provider_id.clone(),
+            is_active: None,
+            offset: 0,
+            limit: 10_000,
+        })
+        .await
+        .expect("provider models should load");
+    assert_eq!(provider_models.len(), 1);
+    assert_eq!(provider_models[0].provider_model_name, expected_model_name);
+
+    let test_response = client
+        .post(format!("{gateway_url}/api/admin/provider-query/test-model"))
+        .header(GATEWAY_HEADER, "rust-phase3b")
+        .header(TRUSTED_ADMIN_USER_ID_HEADER, "admin-user-123")
+        .header(TRUSTED_ADMIN_USER_ROLE_HEADER, "admin")
+        .header(TRUSTED_ADMIN_SESSION_ID_HEADER, "session-123")
+        .json(&json!({
+            "provider_id": provider_id,
+            "endpoint_id": endpoint_id,
+            "model": expected_model_name,
+            "api_format": "openai:chat"
+        }))
+        .send()
+        .await
+        .expect("request should succeed");
+
+    assert_eq!(test_response.status(), StatusCode::OK);
+    let test_payload: Value = test_response.json().await.expect("json body should parse");
+    assert_eq!(test_payload["success"], json!(true));
+    assert_eq!(test_payload["model"], json!(expected_model_name));
+    assert_eq!(test_payload["error"], Value::Null);
+    assert_eq!(
+        test_payload["data"]["response"]["choices"][0]["message"]["content"],
+        json!("Hello from imported provider")
+    );
+    assert_eq!(
+        *execution_runtime_hits.lock().expect("mutex should lock"),
+        1
+    );
+
+    gateway_handle.abort();
+    execution_runtime_handle.abort();
+}
+
+#[tokio::test]
+async fn gateway_rejects_unknown_admin_system_config_import_versions() {
     let gateway = build_router_with_state(
         AppState::new()
             .expect("gateway should build")
@@ -512,7 +750,7 @@ async fn gateway_rejects_legacy_admin_system_config_import_versions() {
     let (gateway_url, gateway_handle) = start_server(gateway).await;
     let client = reqwest::Client::new();
 
-    for version in ["2.0", "2.1"] {
+    for version in ["1.9", "2.3"] {
         let response = client
             .post(format!("{gateway_url}/api/admin/system/config/import"))
             .header(GATEWAY_HEADER, "rust-phase3b")
@@ -535,7 +773,7 @@ async fn gateway_rejects_legacy_admin_system_config_import_versions() {
             .as_str()
             .expect("detail should be a string");
         assert!(detail.contains(&format!("不支持的配置版本: {version}")));
-        assert!(detail.contains("支持的版本: 2.2"));
+        assert!(detail.contains("支持的版本: 2.0, 2.1, 2.2"));
     }
 
     gateway_handle.abort();
@@ -842,13 +1080,8 @@ async fn gateway_imports_admin_system_config_fixture_v22() {
 }
 
 #[tokio::test]
-async fn gateway_rejects_admin_system_config_fixtures_from_removed_legacy_exports() {
+async fn gateway_imports_admin_system_config_fixtures_from_legacy_exports() {
     for fixture in ["v20", "v21"] {
-        let version = match fixture {
-            "v20" => "2.0",
-            "v21" => "2.1",
-            _ => unreachable!("unexpected fixture"),
-        };
         let gateway = build_router_with_state(
             AppState::new()
                 .expect("gateway should build")
@@ -869,20 +1102,170 @@ async fn gateway_rejects_admin_system_config_fixtures_from_removed_legacy_export
 
         assert_eq!(
             response.status(),
-            StatusCode::BAD_REQUEST,
+            StatusCode::OK,
-            "fixture {fixture} should be rejected"
+            "fixture {fixture} should be accepted for Python migration compatibility"
         );
         let payload: Value = response.json().await.expect("json body should parse");
-        let detail = payload["detail"]
+        assert_eq!(payload["message"], "配置导入成功");
-            .as_str()
+        assert_eq!(payload["stats"]["global_models"]["created"], json!(1));
-            .expect("detail should be a string");
+        assert_eq!(payload["stats"]["providers"]["created"], json!(1));
-        assert!(detail.contains(&format!("不支持的配置版本: {version}")));
-        assert!(detail.contains("支持的版本: 2.2"));
 
         gateway_handle.abort();
     }
 }
 
+#[tokio::test]
+async fn gateway_imports_python_cli_alias_export_and_model_test_smoke() {
+    let seen_plan = Arc::new(Mutex::new(None::<ExecutionPlan>));
+    let seen_plan_clone = Arc::clone(&seen_plan);
+    let execution_runtime = Router::new().route(
+        "/v1/execute/sync",
+        any(move |Json(plan): Json<ExecutionPlan>| {
+            let seen_plan_inner = Arc::clone(&seen_plan_clone);
+            async move {
+                assert_eq!(plan.provider_api_format, "claude:messages");
+                assert_eq!(plan.model_name.as_deref(), Some("claude-sonnet-python"));
+                assert_eq!(
+                    plan.body
+                        .json_body
+                        .as_ref()
+                        .and_then(|body| body.get("model")),
+                    Some(&json!("claude-sonnet-python"))
+                );
+                *seen_plan_inner.lock().expect("mutex should lock") = Some(plan.clone());
+                Json(json!({
+                    "request_id": plan.request_id,
+                    "candidate_id": plan.candidate_id,
+                    "status_code": 200,
+                    "headers": {
+                        "content-type": "application/json"
+                    },
+                    "body": {
+                        "json_body": {
+                            "id": "msg_python_alias_smoke",
+                            "type": "message",
+                            "model": "claude-sonnet-python",
+                            "content": [{
+                                "type": "text",
+                                "text": "ok"
+                            }]
+                        }
+                    },
+                    "telemetry": {
+                        "elapsed_ms": 17
+                    }
+                }))
+            }
+        }),
+    );
+    let (execution_runtime_url, execution_runtime_handle) = start_server(execution_runtime).await;
+
+    let provider_catalog_repository = Arc::new(InMemoryProviderCatalogReadRepository::seed(
+        Vec::new(),
+        Vec::new(),
+        Vec::new(),
+    ));
+    let global_model_repository = Arc::new(InMemoryGlobalModelReadRepository::seed(Vec::<
+        StoredPublicGlobalModel,
+    >::new()));
+    let data_state = build_admin_system_data_state_with_repositories(
+        Arc::clone(&provider_catalog_repository),
+        Arc::clone(&global_model_repository),
+    );
+    let gateway = build_router_with_state(
+        build_state_with_execution_runtime_override(execution_runtime_url)
+            .with_data_state_for_tests(data_state),
+    );
+    let (gateway_url, gateway_handle) = start_server(gateway).await;
+
+    let mut import_payload = sample_system_import_payload();
+    import_payload["global_models"][0]["name"] = json!("claude-sonnet-python");
+    import_payload["global_models"][0]["display_name"] = json!("Claude Sonnet Python");
+    import_payload["providers"][0]["name"] = json!("python-export-claude");
+    import_payload["providers"][0]["provider_type"] = json!("custom");
+    import_payload["providers"][0]["endpoints"][0]["api_format"] = json!("claude:cli");
+    import_payload["providers"][0]["endpoints"][0]["base_url"] =
+        json!("https://python-export-claude.example.com");
+    import_payload["providers"][0]["api_keys"][0]["name"] = json!("python-alias-key");
+    import_payload["providers"][0]["api_keys"][0]["api_formats"] = json!(["claude:cli"]);
+    import_payload["providers"][0]["api_keys"][0]["api_key"] = json!("sk-python-alias");
+    import_payload["providers"][0]["models"][0]["global_model_name"] =
+        json!("claude-sonnet-python");
+    import_payload["providers"][0]["models"][0]["provider_model_name"] =
+        json!("claude-sonnet-python");
+
+    let client = reqwest::Client::new();
+    let response = client
+        .post(format!("{gateway_url}/api/admin/system/config/import"))
+        .header(GATEWAY_HEADER, "rust-phase3b")
+        .header(TRUSTED_ADMIN_USER_ID_HEADER, "admin-user-123")
+        .header(TRUSTED_ADMIN_USER_ROLE_HEADER, "admin")
+        .header(TRUSTED_ADMIN_SESSION_ID_HEADER, "session-123")
+        .json(&import_payload)
+        .send()
+        .await
+        .expect("request should succeed");
+
+    let status = response.status();
+    let payload: Value = response.json().await.expect("json body should parse");
+    assert_eq!(status, StatusCode::OK, "payload={payload}");
+
+    let providers = provider_catalog_repository
+        .list_providers(false)
+        .await
+        .expect("providers should load");
+    assert_eq!(providers.len(), 1);
+    let provider_id = providers[0].id.clone();
+    let endpoints = provider_catalog_repository
+        .list_endpoints_by_provider_ids(std::slice::from_ref(&provider_id))
+        .await
+        .expect("endpoints should load");
+    assert_eq!(endpoints.len(), 1);
+    assert_eq!(endpoints[0].api_format, "claude:messages");
+    let keys = provider_catalog_repository
+        .list_keys_by_provider_ids(std::slice::from_ref(&provider_id))
+        .await
+        .expect("keys should load");
+    assert_eq!(keys.len(), 1);
+    assert_eq!(keys[0].api_formats, Some(json!(["claude:messages"])));
+
+    let response = client
+        .post(format!("{gateway_url}/api/admin/provider-query/test-model"))
+        .header(GATEWAY_HEADER, "rust-phase3b")
+        .header(TRUSTED_ADMIN_USER_ID_HEADER, "admin-user-123")
+        .header(TRUSTED_ADMIN_USER_ROLE_HEADER, "admin")
+        .header(TRUSTED_ADMIN_SESSION_ID_HEADER, "session-123")
+        .json(&json!({
+            "provider_id": provider_id,
+            "model": "claude-sonnet-python",
+            "endpoint_id": endpoints[0].id,
+            "api_format": "claude:messages"
+        }))
+        .send()
+        .await
+        .expect("model test request should succeed");
+
+    let status = response.status();
+    let payload: Value = response.json().await.expect("json body should parse");
+    assert_eq!(status, StatusCode::OK, "payload={payload}");
+    assert_eq!(payload["success"], json!(true));
+    assert_eq!(
+        payload["attempts"][0]["endpoint_api_format"],
+        json!("claude:messages")
+    );
+    assert_eq!(
+        payload["attempts"][0]["request_body"]["model"],
+        json!("claude-sonnet-python")
+    );
+    assert!(
+        seen_plan.lock().expect("mutex should lock").is_some(),
+        "post-import model test should execute through runtime"
+    );
+
+    gateway_handle.abort();
+    execution_runtime_handle.abort();
+}
+
 #[tokio::test]
 async fn gateway_rejects_legacy_user_import_string_bool_field() {
     let auth_repository = Arc::new(InMemoryAuthApiKeySnapshotRepository::default());
@@ -964,11 +1347,23 @@ async fn gateway_reports_field_path_for_invalid_admin_system_config_import_shape
 }
 
 #[tokio::test]
-async fn gateway_rejects_admin_system_config_with_numeric_string_prices() {
+async fn gateway_imports_admin_system_config_with_numeric_string_prices() {
+    let provider_catalog_repository = Arc::new(InMemoryProviderCatalogReadRepository::seed(
+        Vec::new(),
+        Vec::new(),
+        Vec::new(),
+    ));
+    let global_model_repository = Arc::new(InMemoryGlobalModelReadRepository::seed(Vec::<
+        StoredPublicGlobalModel,
+    >::new()));
+    let data_state = build_admin_system_data_state_with_repositories(
+        Arc::clone(&provider_catalog_repository),
+        Arc::clone(&global_model_repository),
+    );
     let gateway = build_router_with_state(
         AppState::new()
             .expect("gateway should build")
-            .with_data_state_for_tests(build_empty_admin_system_data_state()),
+            .with_data_state_for_tests(data_state),
     );
     let (gateway_url, gateway_handle) = start_server(gateway).await;
 
@@ -989,11 +1384,37 @@ async fn gateway_rejects_admin_system_config_with_numeric_string_prices() {
         .await
         .expect("request should succeed");
 
-    assert_eq!(response.status(), StatusCode::BAD_REQUEST);
+    let status = response.status();
     let body: Value = response.json().await.expect("json body should parse");
-    let detail = body["detail"].as_str().expect("detail should be a string");
+    assert_eq!(status, StatusCode::OK, "payload={body}");
-    assert!(detail.contains("配置文件格式无效"));
+
-    assert!(detail.contains("default_price_per_request"));
+    let global_models = global_model_repository
+        .list_admin_global_models(&AdminGlobalModelListQuery {
+            offset: 0,
+            limit: 10_000,
+            is_active: None,
+            search: None,
+        })
+        .await
+        .expect("global models should load");
+    assert_eq!(global_models.items[0].default_price_per_request, Some(1.8));
+
+    let providers = provider_catalog_repository
+        .list_providers(false)
+        .await
+        .expect("providers should load");
+    let provider_models = global_model_repository
+        .list_admin_provider_models(&AdminProviderModelListQuery {
+            provider_id: providers[0].id.clone(),
+            is_active: None,
+            offset: 0,
+            limit: 10_000,
+        })
+        .await
+        .expect("provider models should load");
+    assert_eq!(provider_models[0].price_per_request, Some(0.7));
+    assert_eq!(providers[0].request_timeout_secs, Some(30.0));
+    assert_eq!(providers[0].stream_first_byte_timeout_secs, Some(15.0));
 
     gateway_handle.abort();
 }

crates/aether-admin/src/system.rs

@@ -42,7 +42,8 @@ pub struct AdminEmailTemplateUpdate {
 }
 
 pub const ADMIN_SYSTEM_CONFIG_EXPORT_VERSION: &str = "2.2";
-pub const ADMIN_SYSTEM_CONFIG_SUPPORTED_VERSIONS: &[&str] = &[ADMIN_SYSTEM_CONFIG_EXPORT_VERSION];
+pub const ADMIN_SYSTEM_CONFIG_SUPPORTED_VERSIONS: &[&str] =
+    &["2.0", "2.1", ADMIN_SYSTEM_CONFIG_EXPORT_VERSION];
 pub const ADMIN_SYSTEM_USERS_EXPORT_VERSION: &str = "1.4";
 pub const ADMIN_SYSTEM_USERS_SUPPORTED_VERSIONS: &[&str] =
     &["1.3", ADMIN_SYSTEM_USERS_EXPORT_VERSION];
@@ -69,6 +70,21 @@ fn invalid_request(detail: impl Into<String>) -> (http::StatusCode, serde_json::
     )
 }
 
+fn parse_finite_f64_import_value<E>(raw: &str) -> Result<f64, E>
+where
+    E: de::Error,
+{
+    let value = raw
+        .trim()
+        .parse::<f64>()
+        .map_err(|_| E::custom("expected a finite number or numeric string"))?;
+    if value.is_finite() {
+        Ok(value)
+    } else {
+        Err(E::custom("expected a finite number or numeric string"))
+    }
+}
+
 fn deserialize_optional_f64_from_number<'de, D>(deserializer: D) -> Result<Option<f64>, D::Error>
 where
     D: serde::Deserializer<'de>,
@@ -80,8 +96,13 @@ where
             .as_f64()
             .filter(|value| value.is_finite())
             .map(Some)
-            .ok_or_else(|| de::Error::custom("expected a finite number")),
+            .ok_or_else(|| de::Error::custom("expected a finite number or numeric string")),
-        Some(_) => Err(de::Error::custom("expected a finite number")),
+        Some(Value::String(raw)) if !raw.trim().is_empty() => {
+            parse_finite_f64_import_value::<D::Error>(&raw).map(Some)
+        }
+        Some(_) => Err(de::Error::custom(
+            "expected a finite number or numeric string",
+        )),
     }
 }
 
@@ -2182,30 +2203,29 @@ mod tests {
 
     #[test]
     fn parse_admin_system_config_import_request_accepts_supported_versions() {
-        let parsed = parse_admin_system_config_import_request(
+        for version in ADMIN_SYSTEM_CONFIG_SUPPORTED_VERSIONS {
-            json!({
+            let parsed = parse_admin_system_config_import_request(
-                "version": ADMIN_SYSTEM_CONFIG_EXPORT_VERSION,
+                json!({
-                "global_models": [],
+                    "version": version,
-                "providers": [],
+                    "global_models": [],
-            })
+                    "providers": [],
-            .to_string()
+                })
-            .as_bytes(),
+                .to_string()
-        )
+                .as_bytes(),
-        .expect("current version should parse");
+            )
+            .expect("supported version should parse");
 
-        assert_eq!(
+            assert_eq!(parsed.request.document.version, *version);
-            parsed.request.document.version,
+            assert_eq!(parsed.request.merge_mode, AdminImportMergeMode::Skip);
-            ADMIN_SYSTEM_CONFIG_EXPORT_VERSION
+            assert!(parsed.request.document.oauth_providers.is_empty());
-        );
+            assert!(parsed.request.document.system_configs.is_empty());
-        assert_eq!(parsed.request.merge_mode, AdminImportMergeMode::Skip);
+            assert!(parsed.request.document.ldap_config.is_none());
-        assert!(parsed.request.document.oauth_providers.is_empty());
+        }
-        assert!(parsed.request.document.system_configs.is_empty());
-        assert!(parsed.request.document.ldap_config.is_none());
     }
 
     #[test]
-    fn parse_admin_system_config_import_request_rejects_removed_versions() {
+    fn parse_admin_system_config_import_request_rejects_unknown_versions() {
-        for version in ["2.0", "2.1"] {
+        for version in ["1.9", "2.3"] {
             let err = parse_admin_system_config_import_request(
                 json!({
                     "version": version,
@@ -2215,7 +2235,7 @@ mod tests {
                 .to_string()
                 .as_bytes(),
             )
-            .expect_err("removed versions should fail");
+            .expect_err("unknown versions should fail");
 
             assert_eq!(err.0, http::StatusCode::BAD_REQUEST);
             assert_eq!(
@@ -2274,8 +2294,8 @@ mod tests {
     }
 
     #[test]
-    fn parse_admin_system_config_import_request_rejects_numeric_string_fields() {
+    fn parse_admin_system_config_import_request_accepts_numeric_string_fields() {
-        let err = parse_admin_system_config_import_request(
+        let parsed = parse_admin_system_config_import_request(
             json!({
                 "version": "2.2",
                 "global_models": [{
@@ -2298,7 +2318,34 @@ mod tests {
             .to_string()
             .as_bytes(),
         )
-        .expect_err("numeric string fields should fail");
+        .expect("numeric string fields from Python exports should parse");
+
+        let global_model = &parsed.request.document.global_models[0];
+        assert_eq!(global_model.default_price_per_request, Some(1.8));
+
+        let provider = &parsed.request.document.providers[0];
+        assert_eq!(provider.monthly_quota_usd, Some(12.5));
+        assert_eq!(provider.stream_first_byte_timeout, Some(60.0));
+        assert_eq!(provider.request_timeout, Some(120.0));
+        assert_eq!(provider.models[0].price_per_request, Some(0.7));
+    }
+
+    #[test]
+    fn parse_admin_system_config_import_request_rejects_invalid_numeric_string_fields() {
+        let err = parse_admin_system_config_import_request(
+            json!({
+                "version": "2.2",
+                "global_models": [{
+                    "name": "veo3.1",
+                    "display_name": "Veo 3.1",
+                    "default_price_per_request": "not-a-number",
+                }],
+                "providers": [],
+            })
+            .to_string()
+            .as_bytes(),
+        )
+        .expect_err("invalid numeric string fields should fail");
 
         assert_eq!(err.0, http::StatusCode::BAD_REQUEST);
         let detail = err.1["detail"].as_str().expect("detail should be a string");