feat(gateway): unify background task runtime and storage

apps/aether-gateway/src/handlers/admin/provider/crud/delete_task.rs

@@ -1,11 +1,10 @@
-use crate::handlers::admin::provider::delete_task::run_admin_provider_delete_task;
 use crate::handlers::admin::provider::shared::paths::{
     admin_provider_delete_task_parts, admin_provider_id_for_manage_path,
 };
 use crate::handlers::admin::provider::shared::support::build_admin_provider_delete_task_payload;
 use crate::handlers::admin::request::{AdminAppState, AdminRequestContext};
 use crate::handlers::admin::shared::attach_admin_audit_response;
-use crate::{GatewayError, LocalProviderDeleteTaskState};
+use crate::GatewayError;
 use axum::{
     body::Body,
     http,
@@ -13,8 +12,6 @@ use axum::{
     Json,
 };
 use serde_json::json;
-use tracing::warn;
-use uuid::Uuid;
 
 fn build_admin_provider_not_found_response(detail: impl Into<String>) -> Response<Body> {
     (
@@ -60,52 +57,18 @@ pub(crate) async fn maybe_build_local_admin_provider_delete_task_response(
                 "Provider 不存在",
             )));
         };
-        let Some(provider) = state
-            .read_provider_catalog_providers_by_ids(std::slice::from_ref(&provider_id))
-            .await?
-            .into_iter()
-            .next()
+        let Some(task_id) =
+            crate::task_runtime::submit_provider_delete_task(state, &provider_id, Some("admin"))
+                .await?
         else {
             return Ok(Some(build_admin_provider_not_found_response(
                 "提供商不存在",
             )));
         };
-        let task_id = Uuid::new_v4().simple().to_string()[..16].to_string();
-        let pending_task = LocalProviderDeleteTaskState {
-            task_id: task_id.clone(),
-            provider_id: provider.id.clone(),
-            status: "pending".to_string(),
-            stage: "queued".to_string(),
-            total_keys: 0,
-            deleted_keys: 0,
-            total_endpoints: 0,
-            deleted_endpoints: 0,
-            message: "delete task submitted".to_string(),
-        };
-        state.put_provider_delete_task(pending_task.clone());
-        if let Err(err) = state
-            .run_admin_provider_delete_task(&provider.id, &task_id)
-            .await
-        {
-            warn!(
-                "gateway admin provider delete task failed for provider {}: {:?}",
-                provider.id, err
-            );
-            state.put_provider_delete_task(LocalProviderDeleteTaskState {
-                task_id: task_id.clone(),
-                provider_id: provider.id.clone(),
-                status: "failed".to_string(),
-                stage: "failed".to_string(),
-                total_keys: 0,
-                deleted_keys: 0,
-                total_endpoints: 0,
-                deleted_endpoints: 0,
-                message: format!("provider delete failed: {err:?}"),
-            });
-        }
         return Ok(Some(attach_admin_audit_response(
             Json(json!({
                 "task_id": task_id,
+                "run_id": task_id,
                 "status": "pending",
                 "message": "删除任务已提交，提供商已进入后台删除队列",
             }))
@@ -113,7 +76,7 @@ pub(crate) async fn maybe_build_local_admin_provider_delete_task_response(
             "admin_provider_delete_queued",
             "delete_provider",
             "provider",
-            &provider.id,
+            &provider_id,
         )));
     }
 

apps/aether-gateway/src/handlers/admin/provider/oauth/dispatch/batch/task.rs

@@ -15,7 +15,14 @@ use crate::handlers::admin::provider::oauth::state::{
 };
 use crate::handlers::admin::provider::shared::paths::admin_provider_oauth_batch_import_task_provider_id;
 use crate::handlers::admin::request::{AdminAppState, AdminRequestContext};
+use crate::task_runtime::{
+    append_event_with_logging, now_unix_secs, task_definition, update_run_status,
+    upsert_run_with_logging, TASK_KEY_PROVIDER_OAUTH_BATCH_IMPORT,
+};
 use crate::GatewayError;
+use aether_data_contracts::repository::background_tasks::{
+    BackgroundTaskKind, BackgroundTaskStatus, UpsertBackgroundTaskRun,
+};
 use axum::{
     body::Bytes,
     http,
@@ -133,11 +140,7 @@ pub(in super::super) async fn handle_admin_provider_oauth_start_batch_import_tas
     }
 
     let task_id = Uuid::new_v4().to_string();
-    let created_at = SystemTime::now()
-        .duration_since(UNIX_EPOCH)
-        .ok()
-        .map(|duration| duration.as_secs())
-        .unwrap_or(0);
+    let created_at = now_unix_secs();
     let submitted_state = build_admin_provider_oauth_batch_task_state(
         &task_id,
         &provider_id,
@@ -167,6 +170,50 @@ pub(in super::super) async fn handle_admin_provider_oauth_start_batch_import_tas
         ));
     }
 
+    if state.has_background_task_data_writer() {
+        let max_attempts = task_definition(TASK_KEY_PROVIDER_OAUTH_BATCH_IMPORT)
+            .map(|item| item.retry_policy.max_attempts)
+            .unwrap_or(1);
+        let run = UpsertBackgroundTaskRun {
+            id: task_id.clone(),
+            task_key: TASK_KEY_PROVIDER_OAUTH_BATCH_IMPORT.to_string(),
+            kind: BackgroundTaskKind::OnDemand,
+            trigger: "manual".to_string(),
+            status: BackgroundTaskStatus::Queued,
+            attempt: 1,
+            max_attempts,
+            owner_instance: Some(state.app().tunnel.local_instance_id().to_string()),
+            progress_percent: 0,
+            progress_message: Some("provider oauth batch import queued".to_string()),
+            payload_json: Some(json!({
+                "provider_id": provider_id.clone(),
+                "provider_type": provider_type.clone(),
+                "total": total,
+            })),
+            result_json: None,
+            error_message: None,
+            cancel_requested: false,
+            created_by: Some("admin".to_string()),
+            created_at_unix_secs: created_at,
+            started_at_unix_secs: None,
+            finished_at_unix_secs: None,
+            updated_at_unix_secs: created_at,
+        };
+        let _ = upsert_run_with_logging(state.app(), run).await;
+        append_event_with_logging(
+            state.app(),
+            &task_id,
+            "queued",
+            "provider oauth batch import queued",
+            Some(json!({
+                "provider_id": provider_id.clone(),
+                "provider_type": provider_type.clone(),
+                "total": total,
+            })),
+        )
+        .await;
+    }
+
     let task_state = state.cloned_app();
     let task_id_for_worker = task_id.clone();
     let provider_id_for_worker = provider_id.clone();
@@ -201,6 +248,27 @@ pub(in super::super) async fn handle_admin_provider_oauth_start_batch_import_tas
             .save_provider_oauth_batch_task_payload(&task_id_for_worker, &processing_state)
             .await;
 
+        let _ = update_run_status(
+            &task_state,
+            &task_id_for_worker,
+            BackgroundTaskStatus::Running,
+            Some(1),
+            Some("provider oauth batch import started".to_string()),
+            None,
+            None,
+            Some(started_at),
+            None,
+        )
+        .await;
+        append_event_with_logging(
+            &task_state,
+            &task_id_for_worker,
+            "running",
+            "provider oauth batch import started",
+            None,
+        )
+        .await;
+
         let mut progress_reporter = BatchTaskProgressReporter {
             app: task_state.clone(),
             task_id: task_id_for_worker.clone(),
@@ -270,6 +338,34 @@ pub(in super::super) async fn handle_admin_provider_oauth_start_batch_import_tas
                 let _ = AdminAppState::new(&task_state)
                     .save_provider_oauth_batch_task_payload(&task_id_for_worker, &completed_state)
                     .await;
+                let _ = update_run_status(
+                    &task_state,
+                    &task_id_for_worker,
+                    BackgroundTaskStatus::Succeeded,
+                    Some(100),
+                    Some(message),
+                    Some(json!({
+                        "provider_id": provider_id_for_worker,
+                        "provider_type": provider_type_for_worker,
+                        "total": outcome.total,
+                        "success": outcome.success,
+                        "failed": outcome.failed,
+                        "created_count": created_count,
+                        "replaced_count": replaced_count,
+                    })),
+                    None,
+                    None,
+                    Some(finished_at),
+                )
+                .await;
+                append_event_with_logging(
+                    &task_state,
+                    &task_id_for_worker,
+                    "succeeded",
+                    "provider oauth batch import completed",
+                    None,
+                )
+                .await;
             }
             Err(err) => {
                 let finished_at = SystemTime::now()
@@ -299,6 +395,26 @@ pub(in super::super) async fn handle_admin_provider_oauth_start_batch_import_tas
                 let _ = AdminAppState::new(&task_state)
                     .save_provider_oauth_batch_task_payload(&task_id_for_worker, &failed_state)
                     .await;
+                let _ = update_run_status(
+                    &task_state,
+                    &task_id_for_worker,
+                    BackgroundTaskStatus::Failed,
+                    Some(100),
+                    Some("provider oauth batch import failed".to_string()),
+                    None,
+                    Some(error_message.clone()),
+                    None,
+                    Some(finished_at),
+                )
+                .await;
+                append_event_with_logging(
+                    &task_state,
+                    &task_id_for_worker,
+                    "failed",
+                    "provider oauth batch import failed",
+                    Some(json!({ "error": error_message.clone() })),
+                )
+                .await;
                 tracing::warn!(
                     task_id = %task_id_for_worker,
                     provider_id = %provider_id_for_worker,

apps/aether-gateway/src/handlers/admin/provider/oauth/runtime.rs

@@ -4,6 +4,7 @@ use super::quota::codex::refresh_codex_provider_quota_locally;
 use super::quota::kiro::refresh_kiro_provider_quota_locally;
 use crate::handlers::admin::request::AdminAppState;
 use crate::provider_key_auth::provider_key_is_oauth_managed;
+use crate::task_runtime::{spawn_fire_and_forget, TASK_KEY_PROVIDER_OAUTH_ACCOUNT_REFRESH};
 use crate::{AppState, GatewayError};
 use aether_contracts::ProxySnapshot;
 use aether_data_contracts::repository::provider_catalog::{
@@ -170,7 +171,7 @@ pub(crate) fn spawn_provider_oauth_account_state_refresh_after_update(
     key_id: String,
     proxy_override: Option<ProxySnapshot>,
 ) {
-    tokio::spawn(async move {
+    spawn_fire_and_forget(TASK_KEY_PROVIDER_OAUTH_ACCOUNT_REFRESH, async move {
         let _ = refresh_provider_oauth_account_state_after_update(
             &AdminAppState::new(&app),
             &provider,

apps/aether-gateway/src/handlers/admin/provider/ops/providers/balance_cache.rs

@@ -1,5 +1,6 @@
 use super::actions::admin_provider_ops_local_action_response;
 use crate::handlers::admin::request::AdminAppState;
+use crate::task_runtime::{spawn_fire_and_forget, TASK_KEY_PROVIDER_BALANCE_REFRESH};
 use serde_json::{json, Value};
 use std::collections::HashSet;
 use std::time::Duration;
@@ -130,7 +131,7 @@ pub(super) async fn spawn_admin_provider_ops_balance_refresh(
 
     let app = state.cloned_app();
     let provider_id = provider_id.to_string();
-    tokio::spawn(async move {
+    spawn_fire_and_forget(TASK_KEY_PROVIDER_BALANCE_REFRESH, async move {
         let permit = match tokio::time::timeout(
             Duration::from_secs(5),
             ADMIN_PROVIDER_OPS_BALANCE_REFRESH_SEMAPHORE.acquire(),