feat: workerize external generation

server-rs/crates/api-server/src/app.rs

@@ -4119,8 +4119,7 @@ mod tests {
             .await
             .expect("banners body should collect")
             .to_bytes();
-        let payload: Value =
-            serde_json::from_slice(&body).expect("banners payload should be json");
+        let payload: Value = serde_json::from_slice(&body).expect("banners payload should be json");
 
         assert_eq!(payload["eventBanners"][0]["title"], "后台表单公告");
         assert_eq!(payload["eventBanners"][0]["renderMode"], "html");

server-rs/crates/api-server/src/asset_billing.rs

@@ -48,7 +48,7 @@ where
     match operation.await {
         Ok(value) => Ok(value),
         Err(error) => {
-            if points_consumed {
+            if points_consumed && should_refund_asset_operation_error(&error) {
                 refund_asset_operation_points(
                     state,
                     owner_user_id,
@@ -63,6 +63,20 @@ where
     }
 }
 
+pub(crate) fn should_refund_asset_operation_error(error: &AppError) -> bool {
+    let message = error.body_text();
+    // 中文注释：worker lease guard 拒绝表示当前进程已失去队列写权限；
+    // 这类 stale worker 失败不能补偿退款，否则可能冲掉后续合法 worker 的同一账本扣费。
+    !(message.contains("external_generation_job")
+        && (message.contains("lease")
+            || message.contains("worker")
+            || message.contains("job_kind")
+            || message.contains("source_")
+            || message.contains("owner_user_id")
+            || message.contains("不存在")
+            || message.contains("不是 running 状态")))
+}
+
 /// 资产操作统一预扣泥点；扣费流水 ID 由业务资源 ID 参与构造，保证重试幂等。
 async fn consume_asset_operation_points(
     state: &AppState,
@@ -200,4 +214,31 @@ mod tests {
             &SpacetimeClientError::Procedure("泥点余额不足".to_string()),
         ));
     }
+
+    #[test]
+    fn asset_operation_billing_does_not_refund_stale_worker_lease_errors() {
+        let stale_error = AppError::from_status(StatusCode::BAD_GATEWAY).with_details(json!({
+            "provider": "spacetimedb",
+            "message": "external_generation_job lease 已过期",
+        }));
+        let completed_job_error =
+            AppError::from_status(StatusCode::BAD_GATEWAY).with_details(json!({
+                "provider": "spacetimedb",
+                "message": "external_generation_job 当前不是 running 状态",
+            }));
+        let missing_job_error =
+            AppError::from_status(StatusCode::BAD_GATEWAY).with_details(json!({
+                "provider": "spacetimedb",
+                "message": "external_generation_job 不存在",
+            }));
+        let ordinary_error = AppError::from_status(StatusCode::BAD_GATEWAY).with_details(json!({
+            "provider": "vector-engine",
+            "message": "图片生成失败",
+        }));
+
+        assert!(!should_refund_asset_operation_error(&stale_error));
+        assert!(!should_refund_asset_operation_error(&completed_job_error));
+        assert!(!should_refund_asset_operation_error(&missing_job_error));
+        assert!(should_refund_asset_operation_error(&ordinary_error));
+    }
 }

server-rs/crates/api-server/src/config.rs

@@ -21,6 +21,11 @@ pub struct AppConfig {
     pub bind_port: u16,
     pub listen_backlog: i32,
     pub worker_threads: Option<usize>,
+    pub process_role: ProcessRole,
+    pub external_generation_worker_id: String,
+    pub external_generation_worker_concurrency: usize,
+    pub external_generation_worker_poll_interval: Duration,
+    pub external_generation_worker_lease: Duration,
     pub max_concurrent_requests: Option<usize>,
     pub gallery_max_concurrent_requests: Option<usize>,
     pub detail_max_concurrent_requests: Option<usize>,
@@ -159,6 +164,31 @@ pub struct AppConfig {
     pub slow_request_threshold_ms: u64,
 }
 
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum ProcessRole {
+    Api,
+    ExternalGenerationWorker,
+    All,
+}
+
+impl ProcessRole {
+    pub fn as_str(self) -> &'static str {
+        match self {
+            Self::Api => "api",
+            Self::ExternalGenerationWorker => "external-generation-worker",
+            Self::All => "all",
+        }
+    }
+
+    pub fn runs_http(self) -> bool {
+        matches!(self, Self::Api | Self::All)
+    }
+
+    pub fn runs_external_generation_worker(self) -> bool {
+        matches!(self, Self::ExternalGenerationWorker | Self::All)
+    }
+}
+
 impl Default for AppConfig {
     fn default() -> Self {
         Self {
@@ -166,6 +196,11 @@ impl Default for AppConfig {
             bind_port: 3000,
             listen_backlog: 1024,
             worker_threads: None,
+            process_role: ProcessRole::Api,
+            external_generation_worker_id: default_external_generation_worker_id(),
+            external_generation_worker_concurrency: 2,
+            external_generation_worker_poll_interval: Duration::from_millis(2_000),
+            external_generation_worker_lease: Duration::from_secs(3_600),
             max_concurrent_requests: None,
             gallery_max_concurrent_requests: None,
             detail_max_concurrent_requests: None,
@@ -347,6 +382,30 @@ impl AppConfig {
         if let Some(worker_threads) = read_first_usize_env(&["GENARRATIVE_API_WORKER_THREADS"]) {
             config.worker_threads = Some(worker_threads);
         }
+        if let Some(process_role) = read_first_process_role_env(&["GENARRATIVE_PROCESS_ROLE"]) {
+            config.process_role = process_role;
+        }
+        if let Some(worker_id) =
+            read_first_non_empty_env(&["GENARRATIVE_EXTERNAL_GENERATION_WORKER_ID"])
+        {
+            config.external_generation_worker_id = worker_id;
+        }
+        if let Some(concurrency) =
+            read_first_usize_env(&["GENARRATIVE_EXTERNAL_GENERATION_WORKER_CONCURRENCY"])
+        {
+            config.external_generation_worker_concurrency = concurrency.max(1);
+        }
+        if let Some(poll_interval_ms) = read_first_positive_u64_env(&[
+            "GENARRATIVE_EXTERNAL_GENERATION_WORKER_POLL_INTERVAL_MS",
+        ]) {
+            config.external_generation_worker_poll_interval =
+                Duration::from_millis(poll_interval_ms);
+        }
+        if let Some(lease_seconds) = read_first_duration_seconds_env(&[
+            "GENARRATIVE_EXTERNAL_GENERATION_WORKER_LEASE_SECONDS",
+        ]) {
+            config.external_generation_worker_lease = Duration::from_secs(lease_seconds.max(1));
+        }
         if let Some(max_concurrent_requests) =
             read_first_usize_env(&["GENARRATIVE_API_MAX_CONCURRENT_REQUESTS"])
         {
@@ -979,6 +1038,14 @@ fn read_first_llm_provider_env(keys: &[&str]) -> Option<LlmProvider> {
     })
 }
 
+fn read_first_process_role_env(keys: &[&str]) -> Option<ProcessRole> {
+    keys.iter().find_map(|key| {
+        env::var(key)
+            .ok()
+            .and_then(|value| parse_process_role(&value))
+    })
+}
+
 fn read_first_positive_u32_env(keys: &[&str]) -> Option<u32> {
     keys.iter().find_map(|key| {
         env::var(key)
@@ -1026,6 +1093,36 @@ fn read_first_u8_env(keys: &[&str]) -> Option<u8> {
         .find_map(|key| env::var(key).ok().and_then(|value| parse_u8(&value)))
 }
 
+fn default_external_generation_worker_id() -> String {
+    let host = env::var("HOSTNAME")
+        .or_else(|_| env::var("COMPUTERNAME"))
+        .unwrap_or_else(|_| "local".to_string());
+    format!("{}-{}", host.trim(), std::process::id())
+}
+
+fn parse_process_role(value: &str) -> Option<ProcessRole> {
+    match trim_quoted_env_value(value).to_ascii_lowercase().as_str() {
+        "api" => Some(ProcessRole::Api),
+        "external-generation-worker" | "external_generation_worker" | "worker" => {
+            Some(ProcessRole::ExternalGenerationWorker)
+        }
+        "all" => Some(ProcessRole::All),
+        _ => None,
+    }
+}
+
+fn trim_quoted_env_value(raw: &str) -> &str {
+    let raw = raw.trim();
+    raw.strip_prefix('"')
+        .and_then(|value| value.strip_suffix('"'))
+        .or_else(|| {
+            raw.strip_prefix('\'')
+                .and_then(|value| value.strip_suffix('\''))
+        })
+        .unwrap_or(raw)
+        .trim()
+}
+
 fn read_first_positive_u16_env(keys: &[&str]) -> Option<u16> {
     keys.iter().find_map(|key| {
         env::var(key)
@@ -1146,7 +1243,8 @@ fn parse_positive_u16(raw: &str) -> Option<u16> {
 #[cfg(test)]
 mod tests {
     use super::{
-        AppConfig, DEFAULT_VECTOR_ENGINE_IMAGE_REQUEST_TIMEOUT_MS, LlmProvider, parse_bool,
+        AppConfig, DEFAULT_VECTOR_ENGINE_IMAGE_REQUEST_TIMEOUT_MS, LlmProvider, ProcessRole,
+        parse_bool, parse_process_role,
     };
     use std::sync::{Mutex, OnceLock};
 
@@ -1188,6 +1286,32 @@ mod tests {
         assert_eq!(parse_bool("'off'"), Some(false));
     }
 
+    #[test]
+    fn process_role_controls_http_and_external_generation_worker_roles() {
+        assert_eq!(parse_process_role("api"), Some(ProcessRole::Api));
+        assert_eq!(
+            parse_process_role("\"external-generation-worker\""),
+            Some(ProcessRole::ExternalGenerationWorker)
+        );
+        assert_eq!(
+            parse_process_role("'external_generation_worker'"),
+            Some(ProcessRole::ExternalGenerationWorker)
+        );
+        assert_eq!(
+            parse_process_role("worker"),
+            Some(ProcessRole::ExternalGenerationWorker)
+        );
+        assert_eq!(parse_process_role("all"), Some(ProcessRole::All));
+        assert_eq!(parse_process_role("unknown"), None);
+
+        assert!(ProcessRole::Api.runs_http());
+        assert!(!ProcessRole::Api.runs_external_generation_worker());
+        assert!(!ProcessRole::ExternalGenerationWorker.runs_http());
+        assert!(ProcessRole::ExternalGenerationWorker.runs_external_generation_worker());
+        assert!(ProcessRole::All.runs_http());
+        assert!(ProcessRole::All.runs_external_generation_worker());
+    }
+
     #[test]
     fn from_env_reads_sms_enabled_when_shell_value_keeps_quotes() {
         let _guard = ENV_LOCK

server-rs/crates/api-server/src/external_generation_worker.rs

@@ -0,0 +1,572 @@
+use std::{future::Future, io, pin::Pin, time::Duration};
+
+use axum::extract::FromRef;
+use serde_json::json;
+use shared_kernel::offset_datetime_to_unix_micros;
+use spacetime_client::{
+    ExternalGenerationJobClaimRecordInput, ExternalGenerationJobCompleteRecordInput,
+    ExternalGenerationJobFailRecordInput, ExternalGenerationJobRecord,
+    ExternalGenerationJobRenewLeaseRecordInput,
+};
+use tokio::{
+    task::JoinSet,
+    time::{Instant, sleep},
+};
+use tracing::{error, info, warn};
+
+use crate::{
+    puzzle::{
+        ExternalGenerationWriteLeaseGuard, PuzzleCompileDraftWorkerPayload,
+        PuzzleGenerateImagesWorkerPayload, PuzzleGenerateUiBackgroundWorkerPayload,
+        execute_puzzle_compile_draft_worker_job, execute_puzzle_generate_images_worker_job,
+        execute_puzzle_generate_ui_background_worker_job,
+    },
+    request_context::RequestContext,
+    state::{AppState, PuzzleApiState},
+};
+
+pub(crate) const PUZZLE_COMPILE_DRAFT_JOB_KIND: &str = "puzzle_compile_draft";
+pub(crate) const PUZZLE_GENERATE_IMAGES_JOB_KIND: &str = "puzzle_generate_images";
+pub(crate) const PUZZLE_GENERATE_UI_BACKGROUND_JOB_KIND: &str = "puzzle_generate_ui_background";
+
+pub(crate) async fn run_external_generation_worker(state: AppState) -> Result<(), io::Error> {
+    let worker_id = state.config.external_generation_worker_id.clone();
+    let concurrency = state.config.external_generation_worker_concurrency.max(1);
+    let poll_interval = state.config.external_generation_worker_poll_interval;
+    let lease = state.config.external_generation_worker_lease;
+    let mut tasks = JoinSet::new();
+    let mut shutdown = external_generation_worker_shutdown_signal();
+
+    info!(
+        worker_id,
+        concurrency,
+        poll_interval_ms = poll_interval.as_millis(),
+        lease_seconds = lease.as_secs(),
+        "external generation worker 已启动"
+    );
+
+    loop {
+        while tasks.len() >= concurrency {
+            if await_worker_task_or_shutdown(&mut tasks, &mut shutdown).await {
+                drain_external_generation_worker_tasks(&mut tasks).await;
+                return Ok(());
+            }
+        }
+
+        let available = concurrency.saturating_sub(tasks.len()).max(1);
+        let now_micros = current_utc_micros();
+        let lease_expires_at_micros = now_micros.saturating_add(duration_micros_i64(lease));
+
+        let claim_jobs = state.spacetime_client().claim_external_generation_jobs(
+            ExternalGenerationJobClaimRecordInput {
+                worker_id: worker_id.clone(),
+                limit: available.min(u32::MAX as usize) as u32,
+                lease_expires_at_micros,
+                claimed_at_micros: now_micros,
+            },
+        );
+        tokio::pin!(claim_jobs);
+        let jobs = match tokio::select! {
+            _ = shutdown.as_mut() => {
+                drain_external_generation_worker_tasks(&mut tasks).await;
+                return Ok(());
+            }
+            result = &mut claim_jobs => result
+        } {
+            Ok(jobs) => jobs,
+            Err(error) => {
+                error!(error = %error, "领取外部生成任务失败，等待下一轮重试");
+                if await_one_task_or_sleep_or_shutdown(
+                    &mut tasks,
+                    sleep(poll_interval),
+                    &mut shutdown,
+                )
+                .await
+                {
+                    drain_external_generation_worker_tasks(&mut tasks).await;
+                    return Ok(());
+                }
+                continue;
+            }
+        };
+
+        if jobs.is_empty() {
+            if await_one_task_or_sleep_or_shutdown(&mut tasks, sleep(poll_interval), &mut shutdown)
+                .await
+            {
+                drain_external_generation_worker_tasks(&mut tasks).await;
+                return Ok(());
+            }
+            continue;
+        }
+
+        for job in jobs {
+            let state = state.clone();
+            let worker_id = worker_id.clone();
+            tasks.spawn(async move {
+                if let Err(error) =
+                    process_external_generation_job(state, worker_id, lease, job).await
+                {
+                    error!(error = %error, "external generation worker 执行任务失败");
+                }
+            });
+        }
+    }
+}
+
+type ExternalGenerationShutdownSignal = Pin<Box<dyn Future<Output = ()> + Send>>;
+
+fn external_generation_worker_shutdown_signal() -> ExternalGenerationShutdownSignal {
+    Box::pin(async {
+        wait_for_external_generation_worker_shutdown_signal().await;
+    })
+}
+
+#[cfg(unix)]
+async fn wait_for_external_generation_worker_shutdown_signal() {
+    use tokio::signal::unix::{SignalKind, signal};
+
+    let mut sigterm = signal(SignalKind::terminate()).ok();
+    tokio::select! {
+        result = tokio::signal::ctrl_c() => {
+            if let Err(error) = result {
+                warn!(error = %error, "external generation worker 监听 SIGINT 失败");
+            }
+        }
+        _ = async {
+            if let Some(sigterm) = sigterm.as_mut() {
+                sigterm.recv().await;
+            } else {
+                std::future::pending::<()>().await;
+            }
+        } => {}
+    }
+}
+
+#[cfg(not(unix))]
+async fn wait_for_external_generation_worker_shutdown_signal() {
+    if let Err(error) = tokio::signal::ctrl_c().await {
+        warn!(error = %error, "external generation worker 监听 Ctrl-C 失败");
+    }
+}
+
+async fn await_worker_task(tasks: &mut JoinSet<()>) {
+    if let Some(result) = tasks.join_next().await
+        && let Err(error) = result
+    {
+        error!(error = %error, "external generation worker 子任务 panic");
+    }
+}
+
+async fn await_worker_task_or_shutdown(
+    tasks: &mut JoinSet<()>,
+    shutdown: &mut ExternalGenerationShutdownSignal,
+) -> bool {
+    tokio::select! {
+        _ = shutdown.as_mut() => true,
+        _ = await_worker_task(tasks) => false,
+    }
+}
+
+async fn await_one_task_or_sleep_or_shutdown(
+    tasks: &mut JoinSet<()>,
+    sleeper: impl Future<Output = ()>,
+    shutdown: &mut ExternalGenerationShutdownSignal,
+) -> bool {
+    tokio::pin!(sleeper);
+    if tasks.is_empty() {
+        tokio::select! {
+            _ = shutdown.as_mut() => true,
+            _ = &mut sleeper => false,
+        }
+    } else {
+        tokio::select! {
+            _ = shutdown.as_mut() => true,
+            _ = &mut sleeper => false,
+            result = tasks.join_next() => {
+                if let Some(Err(error)) = result {
+                    error!(error = %error, "external generation worker 子任务 panic");
+                }
+                false
+            }
+        }
+    }
+}
+
+async fn drain_external_generation_worker_tasks(tasks: &mut JoinSet<()>) {
+    info!(
+        in_flight_jobs = tasks.len(),
+        "external generation worker 收到停机信号，停止领取新任务并等待当前任务完成"
+    );
+    while !tasks.is_empty() {
+        await_worker_task(tasks).await;
+    }
+    info!("external generation worker 已完成优雅停机");
+}
+
+async fn process_external_generation_job(
+    state: AppState,
+    worker_id: String,
+    lease: Duration,
+    job: ExternalGenerationJobRecord,
+) -> Result<(), String> {
+    let heartbeat_interval = external_generation_worker_heartbeat_interval(lease);
+    let work = process_external_generation_job_once(state.clone(), worker_id.clone(), job.clone());
+    tokio::pin!(work);
+    let heartbeat = sleep(heartbeat_interval);
+    tokio::pin!(heartbeat);
+
+    loop {
+        tokio::select! {
+            biased;
+            result = &mut work => return result,
+            _ = &mut heartbeat => {
+                renew_job_lease(&state, &worker_id, &job, lease).await?;
+                heartbeat.as_mut().reset(Instant::now() + heartbeat_interval);
+            }
+        }
+    }
+}
+
+async fn process_external_generation_job_once(
+    state: AppState,
+    worker_id: String,
+    job: ExternalGenerationJobRecord,
+) -> Result<(), String> {
+    match job.job_kind.as_str() {
+        PUZZLE_COMPILE_DRAFT_JOB_KIND => {
+            let payload = match serde_json::from_str::<PuzzleCompileDraftWorkerPayload>(
+                job.request_payload_json.as_str(),
+            ) {
+                Ok(payload) => payload,
+                Err(error) => {
+                    let message = format!("拼图生成任务参数解析失败：{error}");
+                    fail_job(&state, &worker_id, &job, message.clone()).await?;
+                    return Err(message);
+                }
+            };
+            let request_context = RequestContext::new(
+                format!("external-generation-worker-{}", job.job_id),
+                format!("external-generation-worker {}", job.job_kind),
+                std::time::Duration::ZERO,
+                false,
+            );
+            let puzzle_state = PuzzleApiState::from_ref(&state);
+            let write_guard = build_external_generation_write_lease_guard(&worker_id, &job)?;
+            match execute_puzzle_compile_draft_worker_job(
+                &puzzle_state,
+                &request_context,
+                payload,
+                write_guard,
+            )
+            .await
+            {
+                Ok(session) => {
+                    complete_job(
+                        &state,
+                        &worker_id,
+                        &job,
+                        Some(
+                            json!({
+                                "sessionId": session.session_id,
+                                "progressPercent": session.progress_percent,
+                            })
+                            .to_string(),
+                        ),
+                    )
+                    .await
+                }
+                Err(error) => {
+                    let message = error.body_text();
+                    fail_queue_job_after_worker_error(&state, &worker_id, &job, &error, &message)
+                        .await?;
+                    Err(message)
+                }
+            }
+        }
+        PUZZLE_GENERATE_IMAGES_JOB_KIND => {
+            let payload = match serde_json::from_str::<PuzzleGenerateImagesWorkerPayload>(
+                job.request_payload_json.as_str(),
+            ) {
+                Ok(payload) => payload,
+                Err(error) => {
+                    let message = format!("拼图关卡图片生成任务参数解析失败：{error}");
+                    fail_job(&state, &worker_id, &job, message.clone()).await?;
+                    return Err(message);
+                }
+            };
+            let request_context = RequestContext::new(
+                format!("external-generation-worker-{}", job.job_id),
+                format!("external-generation-worker {}", job.job_kind),
+                std::time::Duration::ZERO,
+                false,
+            );
+            let puzzle_state = PuzzleApiState::from_ref(&state);
+            let write_guard = build_external_generation_write_lease_guard(&worker_id, &job)?;
+            match execute_puzzle_generate_images_worker_job(
+                &puzzle_state,
+                &request_context,
+                payload,
+                write_guard,
+            )
+            .await
+            {
+                Ok(session) => {
+                    complete_job(
+                        &state,
+                        &worker_id,
+                        &job,
+                        Some(
+                            json!({
+                                "sessionId": session.session_id,
+                                "progressPercent": session.progress_percent,
+                            })
+                            .to_string(),
+                        ),
+                    )
+                    .await
+                }
+                Err(error) => {
+                    let message = error.body_text();
+                    fail_queue_job_after_worker_error(&state, &worker_id, &job, &error, &message)
+                        .await?;
+                    Err(message)
+                }
+            }
+        }
+        PUZZLE_GENERATE_UI_BACKGROUND_JOB_KIND => {
+            let payload = match serde_json::from_str::<PuzzleGenerateUiBackgroundWorkerPayload>(
+                job.request_payload_json.as_str(),
+            ) {
+                Ok(payload) => payload,
+                Err(error) => {
+                    let message = format!("拼图 UI 背景图生成任务参数解析失败：{error}");
+                    fail_job(&state, &worker_id, &job, message.clone()).await?;
+                    return Err(message);
+                }
+            };
+            let request_context = RequestContext::new(
+                format!("external-generation-worker-{}", job.job_id),
+                format!("external-generation-worker {}", job.job_kind),
+                std::time::Duration::ZERO,
+                false,
+            );
+            let puzzle_state = PuzzleApiState::from_ref(&state);
+            let write_guard = build_external_generation_write_lease_guard(&worker_id, &job)?;
+            match execute_puzzle_generate_ui_background_worker_job(
+                &puzzle_state,
+                &request_context,
+                payload,
+                write_guard,
+            )
+            .await
+            {
+                Ok(session) => {
+                    complete_job(
+                        &state,
+                        &worker_id,
+                        &job,
+                        Some(
+                            json!({
+                                "sessionId": session.session_id,
+                                "progressPercent": session.progress_percent,
+                            })
+                            .to_string(),
+                        ),
+                    )
+                    .await
+                }
+                Err(error) => {
+                    let message = error.body_text();
+                    fail_queue_job_after_worker_error(&state, &worker_id, &job, &error, &message)
+                        .await?;
+                    Err(message)
+                }
+            }
+        }
+        unknown => {
+            warn!(
+                job_id = job.job_id,
+                job_kind = unknown,
+                "external generation worker 收到暂不支持的任务类型"
+            );
+            fail_job(
+                &state,
+                &worker_id,
+                &job,
+                format!("暂不支持的外部生成任务类型：{unknown}"),
+            )
+            .await
+        }
+    }
+}
+
+async fn fail_queue_job_after_worker_error(
+    state: &AppState,
+    worker_id: &str,
+    job: &ExternalGenerationJobRecord,
+    error: &crate::puzzle::PuzzleExternalGenerationWorkerError,
+    message: &str,
+) -> Result<(), String> {
+    if error.should_fail_queue_job() {
+        return fail_job(state, worker_id, job, message.to_string()).await;
+    }
+
+    warn!(
+        job_id = job.job_id,
+        job_kind = job.job_kind,
+        "external generation worker 业务失败态尚未写回，保留任务租约等待后续重试"
+    );
+    Ok(())
+}
+
+async fn complete_job(
+    state: &AppState,
+    worker_id: &str,
+    job: &ExternalGenerationJobRecord,
+    result_payload_json: Option<String>,
+) -> Result<(), String> {
+    state
+        .spacetime_client()
+        .complete_external_generation_job(ExternalGenerationJobCompleteRecordInput {
+            job_id: job.job_id.clone(),
+            worker_id: worker_id.to_string(),
+            lease_token: require_job_lease_token(job)?,
+            result_payload_json,
+            completed_at_micros: current_utc_micros(),
+        })
+        .await
+        .map(|_| ())
+        .map_err(|error| error.to_string())
+}
+
+async fn fail_job(
+    state: &AppState,
+    worker_id: &str,
+    job: &ExternalGenerationJobRecord,
+    error_message: String,
+) -> Result<(), String> {
+    let now_micros = current_utc_micros();
+    state
+        .spacetime_client()
+        .fail_external_generation_job(ExternalGenerationJobFailRecordInput {
+            job_id: job.job_id.clone(),
+            worker_id: worker_id.to_string(),
+            lease_token: require_job_lease_token(job)?,
+            error_message,
+            retry_after_micros: now_micros.saturating_add(60_000_000),
+            failed_at_micros: now_micros,
+        })
+        .await
+        .map(|_| ())
+        .map_err(|error| error.to_string())
+}
+
+async fn renew_job_lease(
+    state: &AppState,
+    worker_id: &str,
+    job: &ExternalGenerationJobRecord,
+    lease: Duration,
+) -> Result<(), String> {
+    let now_micros = current_utc_micros();
+    state
+        .spacetime_client()
+        .renew_external_generation_job_lease(ExternalGenerationJobRenewLeaseRecordInput {
+            job_id: job.job_id.clone(),
+            worker_id: worker_id.to_string(),
+            lease_token: require_job_lease_token(job)?,
+            lease_expires_at_micros: now_micros.saturating_add(duration_micros_i64(lease)),
+            renewed_at_micros: now_micros,
+        })
+        .await
+        .map(|_| ())
+        .map_err(|error| error.to_string())
+}
+
+fn require_job_lease_token(job: &ExternalGenerationJobRecord) -> Result<String, String> {
+    job.lease_token
+        .as_deref()
+        .map(str::trim)
+        .filter(|value| !value.is_empty())
+        .map(ToOwned::to_owned)
+        .ok_or_else(|| format!("external_generation_job {} 缺少 lease token", job.job_id))
+}
+
+fn build_external_generation_write_lease_guard(
+    worker_id: &str,
+    job: &ExternalGenerationJobRecord,
+) -> Result<ExternalGenerationWriteLeaseGuard, String> {
+    Ok(ExternalGenerationWriteLeaseGuard {
+        job_id: job.job_id.clone(),
+        worker_id: worker_id.to_string(),
+        lease_token: require_job_lease_token(job)?,
+    })
+}
+
+fn duration_micros_i64(duration: Duration) -> i64 {
+    duration.as_micros().min(i64::MAX as u128) as i64
+}
+
+fn external_generation_worker_heartbeat_interval(lease: Duration) -> Duration {
+    let heartbeat_millis = (lease.as_millis() / 3).clamp(250, 30_000) as u64;
+    Duration::from_millis(heartbeat_millis)
+}
+
+fn current_utc_micros() -> i64 {
+    offset_datetime_to_unix_micros(time::OffsetDateTime::now_utc())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn worker_write_guard_uses_claimed_job_lease_token() {
+        let job = external_generation_job_record_fixture(Some("lease-1"));
+
+        let guard = build_external_generation_write_lease_guard("worker-a", &job)
+            .expect("guard should build");
+
+        assert_eq!(guard.job_id, "extgen-1");
+        assert_eq!(guard.worker_id, "worker-a");
+        assert_eq!(guard.lease_token, "lease-1");
+    }
+
+    #[test]
+    fn worker_write_guard_requires_claimed_job_lease_token() {
+        let job = external_generation_job_record_fixture(None);
+
+        let error = build_external_generation_write_lease_guard("worker-a", &job)
+            .expect_err("missing token should fail");
+
+        assert!(error.contains("缺少 lease token"));
+    }
+
+    fn external_generation_job_record_fixture(
+        lease_token: Option<&str>,
+    ) -> ExternalGenerationJobRecord {
+        ExternalGenerationJobRecord {
+            job_id: "extgen-1".to_string(),
+            dedupe_key: "puzzle:generate_puzzle_images:session-1:extgen-1".to_string(),
+            job_kind: PUZZLE_GENERATE_IMAGES_JOB_KIND.to_string(),
+            owner_user_id: "user-1".to_string(),
+            source_module: "puzzle".to_string(),
+            source_entity_id: "session-1:puzzle-level-1".to_string(),
+            request_label: "拼图关卡图片生成".to_string(),
+            request_payload_json: "{}".to_string(),
+            status: "running".to_string(),
+            attempt: 1,
+            max_attempts: 1,
+            last_error_message: None,
+            worker_id: Some("worker-a".to_string()),
+            lease_expires_at: Some("2026-06-03T00:00:00Z".to_string()),
+            available_at: "2026-06-03T00:00:00Z".to_string(),
+            result_payload_json: None,
+            created_at: "2026-06-03T00:00:00Z".to_string(),
+            started_at: Some("2026-06-03T00:00:00Z".to_string()),
+            completed_at: None,
+            updated_at: "2026-06-03T00:00:00Z".to_string(),
+            lease_token: lease_token.map(ToOwned::to_owned),
+        }
+    }
+}

server-rs/crates/api-server/src/main.rs

@@ -40,6 +40,7 @@ mod edutainment_baby_drawing;
 mod edutainment_baby_object;
 mod error_middleware;
 mod external_api_audit;
+mod external_generation_worker;
 pub(crate) mod generated_asset_sheets;
 mod generated_image_assets;
 mod health;
@@ -114,6 +115,7 @@ use tracing::{error, info, warn};
 use crate::{
     app::{build_router, build_spacetime_unavailable_router},
     config::AppConfig,
+    external_generation_worker::run_external_generation_worker,
     state::{AppState, AppStateInitError},
     tracking_outbox::TrackingOutbox,
 };
@@ -164,20 +166,47 @@ async fn run_server(config: AppConfig) -> Result<(), io::Error> {
     process_metrics::register_process_metrics();
     telemetry::register_http_runtime_metrics();
 
+    if !config.process_role.runs_http() {
+        return run_worker_only(config).await;
+    }
+
+    run_http_role(config).await
+}
+
+async fn run_worker_only(config: AppConfig) -> Result<(), io::Error> {
+    let process_role = config.process_role;
+    let state = restore_app_state_for_startup(config)
+        .await
+        .map_err(|error| {
+            io::Error::other(format!(
+                "初始化 external generation worker 状态失败：{error}"
+            ))
+        })?;
+    spawn_app_state_background_workers(&state);
+    info!(
+        process_role = process_role.as_str(),
+        "api-server 以 worker 角色启动"
+    );
+    run_external_generation_worker(state).await
+}
+
+async fn run_http_role(config: AppConfig) -> Result<(), io::Error> {
     let bind_address = config.bind_socket_addr();
     let listen_backlog = config.listen_backlog;
     let worker_threads = config.worker_threads;
     let otel_enabled = config.otel_enabled;
+    let process_role = config.process_role;
     let outbox_flush_timeout = config.shutdown_outbox_flush_timeout;
     let listener = build_tcp_listener(bind_address, listen_backlog)?;
 
-    let (router, shutdown_context) = match restore_app_state_for_startup(config).await {
+    let (router, shutdown_context, worker_state) = match restore_app_state_for_startup(config).await
+    {
         Ok(state) => {
-            state.puzzle_gallery_cache().spawn_cleanup_task();
+            spawn_app_state_background_workers(&state);
             let tracking_outbox = state.tracking_outbox();
-            if let Some(outbox) = tracking_outbox.clone() {
-                outbox.spawn_worker();
-            }
+            let worker_state = process_role
+                .runs_external_generation_worker()
+                .then(|| state.clone());
             (
                 build_router(state.clone()),
                 ShutdownContext {
@@ -185,6 +214,7 @@ async fn run_server(config: AppConfig) -> Result<(), io::Error> {
                     tracking_outbox,
                     outbox_flush_timeout,
                 },
+                worker_state,
             )
         }
         Err(AppStateInitError::DependencyUnavailable(message)) => (
@@ -194,6 +224,7 @@ async fn run_server(config: AppConfig) -> Result<(), io::Error> {
                 tracking_outbox: None,
                 outbox_flush_timeout,
             },
+            None,
         ),
         Err(error) => {
             return Err(std::io::Error::other(format!(
@@ -207,12 +238,20 @@ async fn run_server(config: AppConfig) -> Result<(), io::Error> {
         listen_backlog,
         worker_threads = worker_threads.unwrap_or(0),
         otel_enabled,
+        process_role = process_role.as_str(),
         "api-server 已完成 tracing 初始化并开始监听"
     );
 
-    let result = axum::serve(listener, router)
-        .with_graceful_shutdown(shutdown_signal(shutdown_context.clone()))
-        .await;
+    let http_server = axum::serve(listener, router)
+        .with_graceful_shutdown(shutdown_signal(shutdown_context.clone()));
+    let result = if let Some(worker_state) = worker_state {
+        tokio::select! {
+            result = http_server => result,
+            result = run_external_generation_worker(worker_state) => result,
+        }
+    } else {
+        http_server.await
+    };
     finalize_shutdown(shutdown_context).await;
     result
 }
@@ -304,6 +343,13 @@ async fn finalize_shutdown(context: ShutdownContext) {
     }
 }
 
+fn spawn_app_state_background_workers(state: &AppState) {
+    state.puzzle_gallery_cache().spawn_cleanup_task();
+    if let Some(outbox) = state.tracking_outbox() {
+        outbox.spawn_worker();
+    }
+}
+
 fn build_tcp_listener(
     bind_address: SocketAddr,
     listen_backlog: i32,

server-rs/crates/api-server/src/puzzle.rs

@@ -52,21 +52,21 @@ use shared_contracts::{
 };
 use shared_kernel::{build_prefixed_uuid_id, format_timestamp_micros};
 use spacetime_client::{
-    PuzzleAgentMessageRecord, PuzzleAgentMessageSubmitRecordInput,
-    PuzzleAgentSessionCreateRecordInput, PuzzleAgentSessionRecord,
-    PuzzleAgentSuggestedActionRecord, PuzzleAnchorItemRecord, PuzzleAnchorPackRecord,
-    PuzzleAudioAssetRecord, PuzzleCreatorIntentRecord, PuzzleDraftCompileFailureRecordInput,
-    PuzzleDraftLevelRecord, PuzzleFormDraftRecord, PuzzleFormDraftSaveRecordInput,
-    PuzzleGalleryCardRecord, PuzzleGeneratedImageCandidateRecord,
+    ExternalGenerationJobEnqueueRecordInput, PuzzleAgentMessageRecord,
+    PuzzleAgentMessageSubmitRecordInput, PuzzleAgentSessionCreateRecordInput,
+    PuzzleAgentSessionRecord, PuzzleAgentSuggestedActionRecord, PuzzleAnchorItemRecord,
+    PuzzleAnchorPackRecord, PuzzleAudioAssetRecord, PuzzleCreatorIntentRecord,
+    PuzzleDraftCompileFailureRecordInput, PuzzleDraftLevelRecord, PuzzleFormDraftRecord,
+    PuzzleFormDraftSaveRecordInput, PuzzleGalleryCardRecord, PuzzleGeneratedImageCandidateRecord,
     PuzzleGeneratedImagesSaveRecordInput, PuzzleLeaderboardEntryRecord,
-    PuzzleLeaderboardSubmitRecordInput, PuzzlePublishRecordInput, PuzzleRecommendedNextWorkRecord,
-    PuzzleResultDraftRecord, PuzzleResultPreviewBlockerRecord, PuzzleResultPreviewFindingRecord,
-    PuzzleResultPreviewRecord, PuzzleRunDragRecordInput, PuzzleRunPauseRecordInput,
-    PuzzleRunPropRecordInput, PuzzleRunRecord, PuzzleRunStartRecordInput, PuzzleRunSwapRecordInput,
-    PuzzleSelectCoverImageRecordInput, PuzzleUiBackgroundSaveRecordInput,
-    PuzzleWorkLikeReportRecordInput, PuzzleWorkPointIncentiveClaimRecordInput,
-    PuzzleWorkProfileRecord, PuzzleWorkRemixRecordInput, PuzzleWorkUpsertRecordInput,
-    SpacetimeClientError,
+    PuzzleLeaderboardSubmitRecordInput, PuzzleLevelGenerationFailureRecordInput,
+    PuzzlePublishRecordInput, PuzzleRecommendedNextWorkRecord, PuzzleResultDraftRecord,
+    PuzzleResultPreviewBlockerRecord, PuzzleResultPreviewFindingRecord, PuzzleResultPreviewRecord,
+    PuzzleRunDragRecordInput, PuzzleRunPauseRecordInput, PuzzleRunPropRecordInput, PuzzleRunRecord,
+    PuzzleRunStartRecordInput, PuzzleRunSwapRecordInput, PuzzleSelectCoverImageRecordInput,
+    PuzzleUiBackgroundSaveRecordInput, PuzzleWorkLikeReportRecordInput,
+    PuzzleWorkPointIncentiveClaimRecordInput, PuzzleWorkProfileRecord, PuzzleWorkRemixRecordInput,
+    PuzzleWorkUpsertRecordInput, SpacetimeClientError,
 };
 use std::convert::Infallible;
 
@@ -78,6 +78,10 @@ use crate::{
         should_skip_asset_operation_billing_for_connectivity,
     },
     auth::{AuthenticatedAccessToken, RuntimePrincipal},
+    external_generation_worker::{
+        PUZZLE_COMPILE_DRAFT_JOB_KIND, PUZZLE_GENERATE_IMAGES_JOB_KIND,
+        PUZZLE_GENERATE_UI_BACKGROUND_JOB_KIND,
+    },
     generated_asset_sheets::apply_generated_asset_sheet_green_screen_alpha,
     http_error::AppError,
     llm_model_routing::{CREATION_TEMPLATE_LLM_MODEL, PUZZLE_LEVEL_NAME_VISION_LLM_MODEL},
@@ -130,6 +134,43 @@ const PUZZLE_UI_BACKGROUND_PROMPT_FALLBACK_MARKER: &str =
 const PUZZLE_VECTOR_ENGINE_SQUARE_IMAGE_SIZE: &str = "1024x1024";
 const PUZZLE_VECTOR_ENGINE_PORTRAIT_IMAGE_SIZE: &str = "1024x1536";
 
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) struct ExternalGenerationWriteLeaseGuard {
+    pub(crate) job_id: String,
+    pub(crate) worker_id: String,
+    pub(crate) lease_token: String,
+}
+
+#[derive(Debug)]
+pub(crate) struct PuzzleExternalGenerationWorkerError {
+    error: AppError,
+    should_fail_queue_job: bool,
+}
+
+impl PuzzleExternalGenerationWorkerError {
+    pub(crate) fn with_failure_state_written(error: AppError) -> Self {
+        Self {
+            error,
+            should_fail_queue_job: true,
+        }
+    }
+
+    pub(crate) fn with_failure_state_pending(error: AppError) -> Self {
+        Self {
+            error,
+            should_fail_queue_job: false,
+        }
+    }
+
+    pub(crate) fn body_text(&self) -> String {
+        self.error.body_text()
+    }
+
+    pub(crate) fn should_fail_queue_job(&self) -> bool {
+        self.should_fail_queue_job
+    }
+}
+
 pub(crate) fn format_puzzle_reference_image_upload_bytes(bytes: usize) -> String {
     format!("{:.1}MB", bytes as f64 / 1024.0 / 1024.0)
 }
@@ -152,7 +193,7 @@ mod mappers;
 use self::mappers::*;
 
 mod draft;
-use self::draft::*;
+pub(crate) use self::draft::*;
 
 mod tags;
 
@@ -161,7 +202,7 @@ use self::tags::*;
 mod generation;
 mod vector_engine;
 
-use self::generation::*;
+pub(crate) use self::generation::*;
 use self::vector_engine::*;
 
 #[cfg(test)]

server-rs/crates/api-server/src/puzzle/draft.rs

@@ -137,6 +137,124 @@ pub(crate) async fn create_seeded_puzzle_session_when_form_save_missing(
     Ok(replacement.session_id)
 }
 
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct PuzzleCompileDraftWorkerPayload {
+    pub session_id: String,
+    pub owner_user_id: String,
+    pub billing_asset_id: String,
+    pub ai_redraw: bool,
+    #[serde(default)]
+    pub prompt_text: Option<String>,
+    #[serde(default)]
+    pub reference_image_src: Option<String>,
+    #[serde(default)]
+    pub image_model: Option<String>,
+    pub requested_at_micros: i64,
+}
+
+pub(crate) async fn execute_puzzle_compile_draft_worker_job(
+    state: &PuzzleApiState,
+    request_context: &RequestContext,
+    payload: PuzzleCompileDraftWorkerPayload,
+    external_generation_guard: ExternalGenerationWriteLeaseGuard,
+) -> Result<PuzzleAgentSessionRecord, PuzzleExternalGenerationWorkerError> {
+    let now = current_utc_micros();
+    let session = if payload.ai_redraw {
+        execute_billable_asset_operation_with_cost(
+            state.root_state(),
+            &payload.owner_user_id,
+            "puzzle_initial_image",
+            &payload.billing_asset_id,
+            PUZZLE_IMAGE_GENERATION_POINTS_COST,
+            async {
+                compile_puzzle_draft_with_initial_cover(
+                    state,
+                    request_context,
+                    payload.session_id.clone(),
+                    payload.owner_user_id.clone(),
+                    payload.prompt_text.as_deref(),
+                    payload.reference_image_src.as_deref(),
+                    payload.image_model.as_deref(),
+                    now,
+                    &external_generation_guard,
+                )
+                .await
+            },
+        )
+        .await
+    } else {
+        compile_puzzle_draft_with_uploaded_cover(
+            state,
+            request_context,
+            payload.session_id.clone(),
+            payload.owner_user_id.clone(),
+            payload.prompt_text.as_deref(),
+            payload.reference_image_src.as_deref(),
+            now,
+            &external_generation_guard,
+        )
+        .await
+    };
+
+    match session {
+        Ok(session) => Ok(session),
+        Err(error) => {
+            match mark_puzzle_compile_failure_for_worker(
+                state,
+                &payload.session_id,
+                &payload.owner_user_id,
+                error.body_text(),
+                now,
+                &external_generation_guard,
+            )
+            .await
+            {
+                Ok(()) => {
+                    Err(PuzzleExternalGenerationWorkerError::with_failure_state_written(error))
+                }
+                Err(mark_error) => {
+                    Err(PuzzleExternalGenerationWorkerError::with_failure_state_pending(mark_error))
+                }
+            }
+        }
+    }
+}
+
+pub(crate) async fn mark_puzzle_compile_failure_for_worker(
+    state: &PuzzleApiState,
+    session_id: &str,
+    owner_user_id: &str,
+    error_message: String,
+    failed_at_micros: i64,
+    external_generation_guard: &ExternalGenerationWriteLeaseGuard,
+) -> Result<(), AppError> {
+    let result = state
+        .spacetime_client()
+        .mark_puzzle_draft_generation_failed(PuzzleDraftCompileFailureRecordInput {
+            session_id: session_id.to_string(),
+            owner_user_id: owner_user_id.to_string(),
+            error_message,
+            failed_at_micros,
+            external_generation_job_id: external_generation_guard.job_id.clone(),
+            external_generation_worker_id: external_generation_guard.worker_id.clone(),
+            external_generation_lease_token: external_generation_guard.lease_token.clone(),
+        })
+        .await;
+    if let Err(error) = result {
+        tracing::warn!(
+            provider = PUZZLE_AGENT_API_BASE_PROVIDER,
+            session_id,
+            owner_user_id,
+            message = %error,
+            "拼图 worker 草稿失败态回写失败"
+        );
+        return Err(map_puzzle_client_error(error));
+    }
+
+    Ok(())
+}
+
 pub(crate) fn select_puzzle_level_for_api(
     draft: &PuzzleResultDraftRecord,
     level_id: Option<&str>,
@@ -1186,10 +1304,18 @@ pub(crate) async fn compile_puzzle_draft_with_initial_cover(
     reference_image_src: Option<&str>,
     image_model: Option<&str>,
     now: i64,
+    external_generation_guard: &ExternalGenerationWriteLeaseGuard,
 ) -> Result<PuzzleAgentSessionRecord, AppError> {
     let compiled_session = state
         .spacetime_client()
-        .compile_puzzle_agent_draft(session_id.clone(), owner_user_id.clone(), now)
+        .compile_puzzle_agent_draft_with_external_generation_guard(
+            session_id.clone(),
+            owner_user_id.clone(),
+            now,
+            external_generation_guard.job_id.clone(),
+            external_generation_guard.worker_id.clone(),
+            external_generation_guard.lease_token.clone(),
+        )
         .await
         .map_err(map_puzzle_compile_error)?;
     let draft = compiled_session.draft.clone().ok_or_else(|| {
@@ -1332,7 +1458,7 @@ pub(crate) async fn compile_puzzle_draft_with_initial_cover(
             "message": format!("拼图候选图序列化失败：{error}"),
         }))
     })?;
-    let (saved_session, save_used_fallback) = state
+    let saved_session = state
         .spacetime_client()
         .save_puzzle_generated_images(PuzzleGeneratedImagesSaveRecordInput {
             session_id: compiled_session.session_id.clone(),
@@ -1341,42 +1467,12 @@ pub(crate) async fn compile_puzzle_draft_with_initial_cover(
             levels_json: levels_json_with_generated_name.clone(),
             candidates_json,
             saved_at_micros: current_utc_micros(),
+            external_generation_job_id: external_generation_guard.job_id.clone(),
+            external_generation_worker_id: external_generation_guard.worker_id.clone(),
+            external_generation_lease_token: external_generation_guard.lease_token.clone(),
         })
         .await
-        .map_err(map_puzzle_client_error)
-        .map(|session| (session, false))
-        .or_else(|error| {
-            if is_spacetimedb_connectivity_app_error(&error) {
-                // 中文注释：首图已落 OSS 时，SpacetimeDB 短暂不可用先返回本地快照，避免整次 VectorEngine 生图被判失败。
-                tracing::warn!(
-                    provider = PUZZLE_AGENT_API_BASE_PROVIDER,
-                    session_id = %compiled_session.session_id,
-                    owner_user_id = %owner_user_id,
-                    message = %error.body_text(),
-                    "拼图首图已生成但 SpacetimeDB 草稿回写不可用，降级返回本次生成快照"
-                );
-                let session = apply_generated_puzzle_candidates_to_session_snapshot(
-                    apply_generated_puzzle_levels_to_session_snapshot(
-                        apply_generated_puzzle_first_level_name_to_session_snapshot(
-                            compiled_session.clone(),
-                            target_level.level_id.as_str(),
-                            generated_level_name.as_str(),
-                            fallback_level_name.as_str(),
-                            now,
-                        ),
-                        updated_levels.clone(),
-                        now,
-                    ),
-                    target_level.level_id.as_str(),
-                    candidates.into_records(),
-                    reference_image_src,
-                    now,
-                );
-                Ok((session, true))
-            } else {
-                Err(error)
-            }
-        })?;
+        .map_err(map_puzzle_client_error)?;
     match state
         .spacetime_client()
         .update_puzzle_work(PuzzleWorkUpsertRecordInput {
@@ -1413,9 +1509,6 @@ pub(crate) async fn compile_puzzle_draft_with_initial_cover(
         fallback_level_name.as_str(),
         now,
     );
-    if save_used_fallback {
-        return Ok(saved_session);
-    }
     match state
         .spacetime_client()
         .select_puzzle_cover_image(PuzzleSelectCoverImageRecordInput {
@@ -1454,6 +1547,7 @@ pub(crate) async fn compile_puzzle_draft_with_uploaded_cover(
     prompt_text: Option<&str>,
     reference_image_src: Option<&str>,
     now: i64,
+    external_generation_guard: &ExternalGenerationWriteLeaseGuard,
 ) -> Result<PuzzleAgentSessionRecord, AppError> {
     let uploaded_image_src = reference_image_src
         .map(str::trim)
@@ -1488,7 +1582,14 @@ pub(crate) async fn compile_puzzle_draft_with_uploaded_cover(
             })?;
     let compiled_session = state
         .spacetime_client()
-        .compile_puzzle_agent_draft(session_id.clone(), owner_user_id.clone(), now)
+        .compile_puzzle_agent_draft_with_external_generation_guard(
+            session_id.clone(),
+            owner_user_id.clone(),
+            now,
+            external_generation_guard.job_id.clone(),
+            external_generation_guard.worker_id.clone(),
+            external_generation_guard.lease_token.clone(),
+        )
         .await
         .map_err(map_puzzle_compile_error)?;
     let draft = compiled_session.draft.clone().ok_or_else(|| {
@@ -1628,7 +1729,7 @@ pub(crate) async fn compile_puzzle_draft_with_uploaded_cover(
             "message": format!("拼图上传图候选序列化失败：{error}"),
         }))
     })?;
-    let (saved_session, save_used_fallback) = state
+    let saved_session = state
         .spacetime_client()
         .save_puzzle_generated_images(PuzzleGeneratedImagesSaveRecordInput {
             session_id: compiled_session.session_id.clone(),
@@ -1637,41 +1738,12 @@ pub(crate) async fn compile_puzzle_draft_with_uploaded_cover(
             levels_json: levels_json_with_generated_name.clone(),
             candidates_json,
             saved_at_micros: current_utc_micros(),
+            external_generation_job_id: external_generation_guard.job_id.clone(),
+            external_generation_worker_id: external_generation_guard.worker_id.clone(),
+            external_generation_lease_token: external_generation_guard.lease_token.clone(),
         })
         .await
-        .map_err(map_puzzle_client_error)
-        .map(|session| (session, false))
-        .or_else(|error| {
-            if is_spacetimedb_connectivity_app_error(&error) {
-                tracing::warn!(
-                    provider = PUZZLE_AGENT_API_BASE_PROVIDER,
-                    session_id = %compiled_session.session_id,
-                    owner_user_id = %owner_user_id,
-                    message = %error.body_text(),
-                    "拼图上传图草稿回写不可用，降级返回本地快照"
-                );
-                let session = apply_generated_puzzle_candidates_to_session_snapshot(
-                    apply_generated_puzzle_levels_to_session_snapshot(
-                        apply_generated_puzzle_first_level_name_to_session_snapshot(
-                            compiled_session.clone(),
-                            target_level.level_id.as_str(),
-                            generated_level_name.as_str(),
-                            fallback_level_name.as_str(),
-                            now,
-                        ),
-                        updated_levels.clone(),
-                        now,
-                    ),
-                    target_level.level_id.as_str(),
-                    vec![candidate.clone()],
-                    reference_image_src,
-                    now,
-                );
-                Ok((session, true))
-            } else {
-                Err(error)
-            }
-        })?;
+        .map_err(map_puzzle_client_error)?;
     let (_, profile_id) = build_stable_puzzle_work_ids(&compiled_session.session_id);
     match state
         .spacetime_client()
@@ -1709,9 +1781,6 @@ pub(crate) async fn compile_puzzle_draft_with_uploaded_cover(
         fallback_level_name.as_str(),
         now,
     );
-    if save_used_fallback {
-        return Ok(saved_session);
-    }
     match state
         .spacetime_client()
         .select_puzzle_cover_image(PuzzleSelectCoverImageRecordInput {
@@ -1742,6 +1811,7 @@ pub(crate) async fn compile_puzzle_draft_with_uploaded_cover(
     }
 }
 
+#[cfg(test)]
 pub(crate) fn apply_generated_puzzle_candidates_to_session_snapshot(
     mut session: PuzzleAgentSessionRecord,
     target_level_id: &str,
@@ -1794,23 +1864,7 @@ pub(crate) fn apply_generated_puzzle_candidates_to_session_snapshot(
     session
 }
 
-pub(crate) fn apply_generated_puzzle_levels_to_session_snapshot(
-    mut session: PuzzleAgentSessionRecord,
-    levels: Vec<PuzzleDraftLevelRecord>,
-    updated_at_micros: i64,
-) -> PuzzleAgentSessionRecord {
-    let Some(draft) = session.draft.as_mut() else {
-        return session;
-    };
-    if levels.is_empty() {
-        return session;
-    }
-    draft.levels = levels;
-    sync_puzzle_primary_draft_fields_from_level(draft);
-    session.updated_at = format_timestamp_micros(updated_at_micros);
-    session
-}
-
+#[cfg(test)]
 pub(crate) fn apply_generated_puzzle_first_level_name_to_session_snapshot(
     mut session: PuzzleAgentSessionRecord,
     target_level_id: &str,
@@ -1863,45 +1917,6 @@ pub(crate) fn apply_generated_puzzle_initial_metadata_to_session_snapshot(
     session
 }
 
-pub(crate) fn apply_generated_puzzle_metadata_to_session_snapshot(
-    mut session: PuzzleAgentSessionRecord,
-    target_level_id: &str,
-    metadata: &PuzzleLevelNaming,
-    previous_level_name: &str,
-    updated_at_micros: i64,
-) -> PuzzleAgentSessionRecord {
-    let Some(draft) = session.draft.as_mut() else {
-        return session;
-    };
-    let Some(target_index) = draft
-        .levels
-        .iter()
-        .position(|level| level.level_id == target_level_id)
-        .or_else(|| (!draft.levels.is_empty()).then_some(0))
-    else {
-        return session;
-    };
-
-    draft.levels[target_index].level_name = metadata.level_name.clone();
-    if metadata.ui_background_prompt.is_some() {
-        draft.levels[target_index].ui_background_prompt = metadata.ui_background_prompt.clone();
-    }
-
-    if target_index == 0 {
-        apply_generated_puzzle_initial_metadata_to_draft(
-            draft,
-            metadata,
-            previous_level_name,
-            updated_at_micros,
-        );
-    } else {
-        sync_puzzle_primary_draft_fields_from_level(draft);
-    }
-
-    session.updated_at = format_timestamp_micros(updated_at_micros);
-    session
-}
-
 pub(crate) fn apply_generated_puzzle_initial_metadata_to_draft(
     draft: &mut PuzzleResultDraftRecord,
     metadata: &PuzzleLevelNaming,
@@ -1951,45 +1966,3 @@ pub(crate) fn sync_puzzle_primary_draft_fields_from_level(draft: &mut PuzzleResu
         });
     }
 }
-
-pub(crate) fn replace_puzzle_session_draft_snapshot(
-    mut session: PuzzleAgentSessionRecord,
-    draft: PuzzleResultDraftRecord,
-    updated_at_micros: i64,
-) -> PuzzleAgentSessionRecord {
-    session.draft = Some(draft);
-    session.updated_at = format_timestamp_micros(updated_at_micros);
-    session
-}
-
-pub(crate) fn apply_generated_puzzle_ui_background_to_session_snapshot(
-    mut session: PuzzleAgentSessionRecord,
-    target_level_id: &str,
-    prompt: String,
-    image_src: String,
-    image_object_key: Option<String>,
-    updated_at_micros: i64,
-) -> PuzzleAgentSessionRecord {
-    let Some(draft) = session.draft.as_mut() else {
-        return session;
-    };
-    let Some(target_index) = draft
-        .levels
-        .iter()
-        .position(|level| level.level_id == target_level_id)
-        .or_else(|| (!draft.levels.is_empty()).then_some(0))
-    else {
-        return session;
-    };
-    let level = &mut draft.levels[target_index];
-    level.ui_background_prompt = Some(prompt);
-    level.ui_background_image_src = Some(image_src);
-    level.ui_background_image_object_key = image_object_key;
-    if target_index == 0 {
-        sync_puzzle_primary_draft_fields_from_level(draft);
-    }
-    session.progress_percent = session.progress_percent.max(96);
-    session.last_assistant_reply = Some("拼图 UI 背景图已生成。".to_string());
-    session.updated_at = format_timestamp_micros(updated_at_micros);
-    session
-}

server-rs/crates/api-server/src/puzzle/generation.rs

@@ -22,6 +22,510 @@ pub(crate) fn should_use_uploaded_puzzle_image_directly(
             .is_some_and(|value| !value.is_empty())
 }
 
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct PuzzleGenerateImagesWorkerPayload {
+    pub session_id: String,
+    pub owner_user_id: String,
+    pub billing_asset_id: String,
+    #[serde(default)]
+    pub level_id: Option<String>,
+    #[serde(default)]
+    pub prompt_text: Option<String>,
+    #[serde(default)]
+    pub reference_image_src: Option<String>,
+    #[serde(default)]
+    pub reference_image_srcs: Vec<String>,
+    #[serde(default)]
+    pub reference_image_asset_object_id: Option<String>,
+    #[serde(default)]
+    pub reference_image_asset_object_ids: Vec<String>,
+    #[serde(default)]
+    pub image_model: Option<String>,
+    #[serde(default)]
+    pub ai_redraw: Option<bool>,
+    #[serde(default)]
+    pub should_auto_name_level: Option<bool>,
+    #[serde(default)]
+    pub work_title: Option<String>,
+    #[serde(default)]
+    pub work_description: Option<String>,
+    #[serde(default)]
+    pub picture_description: Option<String>,
+    #[serde(default)]
+    pub summary: Option<String>,
+    #[serde(default)]
+    pub theme_tags: Option<Vec<String>>,
+    #[serde(default)]
+    pub levels_json: Option<String>,
+    pub requested_at_micros: i64,
+}
+
+impl PuzzleGenerateImagesWorkerPayload {
+    fn to_action_request(&self) -> ExecutePuzzleAgentActionRequest {
+        ExecutePuzzleAgentActionRequest {
+            action: "generate_puzzle_images".to_string(),
+            prompt_text: self.prompt_text.clone(),
+            reference_image_src: self.reference_image_src.clone(),
+            reference_image_srcs: self.reference_image_srcs.clone(),
+            reference_image_asset_object_id: self.reference_image_asset_object_id.clone(),
+            reference_image_asset_object_ids: self.reference_image_asset_object_ids.clone(),
+            image_model: self.image_model.clone(),
+            ai_redraw: self.ai_redraw,
+            candidate_count: Some(1),
+            should_auto_name_level: self.should_auto_name_level,
+            candidate_id: None,
+            level_id: self.level_id.clone(),
+            work_title: self.work_title.clone(),
+            work_description: self.work_description.clone(),
+            picture_description: self.picture_description.clone(),
+            level_name: None,
+            summary: self.summary.clone(),
+            theme_tags: self.theme_tags.clone(),
+            levels_json: self.levels_json.clone(),
+        }
+    }
+}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct PuzzleGenerateUiBackgroundWorkerPayload {
+    pub session_id: String,
+    pub owner_user_id: String,
+    pub billing_asset_id: String,
+    #[serde(default)]
+    pub level_id: Option<String>,
+    #[serde(default)]
+    pub prompt_text: Option<String>,
+    #[serde(default)]
+    pub levels_json: Option<String>,
+    pub requested_at_micros: i64,
+}
+
+impl PuzzleGenerateUiBackgroundWorkerPayload {
+    fn to_action_request(&self) -> ExecutePuzzleAgentActionRequest {
+        ExecutePuzzleAgentActionRequest {
+            action: "generate_puzzle_ui_background".to_string(),
+            prompt_text: self.prompt_text.clone(),
+            reference_image_src: None,
+            reference_image_srcs: Vec::new(),
+            reference_image_asset_object_id: None,
+            reference_image_asset_object_ids: Vec::new(),
+            image_model: None,
+            ai_redraw: None,
+            candidate_count: None,
+            should_auto_name_level: None,
+            candidate_id: None,
+            level_id: self.level_id.clone(),
+            work_title: None,
+            work_description: None,
+            picture_description: None,
+            level_name: None,
+            summary: None,
+            theme_tags: None,
+            levels_json: self.levels_json.clone(),
+        }
+    }
+}
+
+pub(crate) async fn execute_puzzle_generate_images_worker_job(
+    state: &PuzzleApiState,
+    request_context: &RequestContext,
+    payload: PuzzleGenerateImagesWorkerPayload,
+    external_generation_guard: ExternalGenerationWriteLeaseGuard,
+) -> Result<PuzzleAgentSessionRecord, PuzzleExternalGenerationWorkerError> {
+    let now = current_utc_micros();
+    let session = execute_billable_asset_operation_with_cost(
+        state.root_state(),
+        &payload.owner_user_id,
+        "puzzle_generated_image",
+        &payload.billing_asset_id,
+        PUZZLE_IMAGE_GENERATION_POINTS_COST,
+        async {
+            execute_puzzle_generate_images_worker_job_inner(
+                state,
+                request_context,
+                &payload,
+                now,
+                &external_generation_guard,
+            )
+            .await
+        },
+    )
+    .await;
+
+    match session {
+        Ok(session) => Ok(session),
+        Err(error) => {
+            match mark_puzzle_level_generation_failure_for_worker(
+                state,
+                &payload,
+                error.body_text(),
+                now,
+                &external_generation_guard,
+            )
+            .await
+            {
+                Ok(()) => {
+                    Err(PuzzleExternalGenerationWorkerError::with_failure_state_written(error))
+                }
+                Err(mark_error) => {
+                    Err(PuzzleExternalGenerationWorkerError::with_failure_state_pending(mark_error))
+                }
+            }
+        }
+    }
+}
+
+pub(crate) async fn execute_puzzle_generate_ui_background_worker_job(
+    state: &PuzzleApiState,
+    request_context: &RequestContext,
+    payload: PuzzleGenerateUiBackgroundWorkerPayload,
+    external_generation_guard: ExternalGenerationWriteLeaseGuard,
+) -> Result<PuzzleAgentSessionRecord, PuzzleExternalGenerationWorkerError> {
+    let now = current_utc_micros();
+    let session = execute_billable_asset_operation_with_cost(
+        state.root_state(),
+        &payload.owner_user_id,
+        "puzzle_ui_background_image",
+        &payload.billing_asset_id,
+        PUZZLE_IMAGE_GENERATION_POINTS_COST,
+        async {
+            execute_puzzle_generate_ui_background_worker_job_inner(
+                state,
+                request_context,
+                &payload,
+                now,
+                &external_generation_guard,
+            )
+            .await
+        },
+    )
+    .await;
+
+    match session {
+        Ok(session) => Ok(session),
+        Err(error) => {
+            match mark_puzzle_level_generation_failure_for_external_generation(
+                state,
+                &payload.session_id,
+                &payload.owner_user_id,
+                payload.level_id.clone(),
+                payload.levels_json.clone(),
+                error.body_text(),
+                now,
+                &external_generation_guard,
+            )
+            .await
+            {
+                Ok(()) => {
+                    Err(PuzzleExternalGenerationWorkerError::with_failure_state_written(error))
+                }
+                Err(mark_error) => {
+                    Err(PuzzleExternalGenerationWorkerError::with_failure_state_pending(mark_error))
+                }
+            }
+        }
+    }
+}
+
+async fn execute_puzzle_generate_images_worker_job_inner(
+    state: &PuzzleApiState,
+    request_context: &RequestContext,
+    payload: &PuzzleGenerateImagesWorkerPayload,
+    now: i64,
+    external_generation_guard: &ExternalGenerationWriteLeaseGuard,
+) -> Result<PuzzleAgentSessionRecord, AppError> {
+    let action_payload = payload.to_action_request();
+    let target_level_id = payload.level_id.clone();
+    let levels_json = payload.levels_json.clone();
+    let session = get_puzzle_session_for_image_generation(
+        state,
+        payload.session_id.clone(),
+        payload.owner_user_id.clone(),
+        &action_payload,
+        levels_json.as_deref(),
+        now,
+    )
+    .await?;
+    let mut draft = session.draft.clone().ok_or_else(|| {
+        AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
+            "provider": PUZZLE_AGENT_API_BASE_PROVIDER,
+            "message": "拼图结果页草稿尚未生成",
+        }))
+    })?;
+    if let Some(levels_json) = levels_json.as_ref() {
+        draft.levels = parse_puzzle_level_records_from_module_json(levels_json)?;
+    }
+    let mut target_level = select_puzzle_level_for_api(&draft, target_level_id.as_deref())?;
+    let prompt = resolve_puzzle_level_image_prompt(
+        payload.prompt_text.as_deref(),
+        &target_level.picture_description,
+        &draft.summary,
+    );
+    let should_auto_name_level = payload
+        .should_auto_name_level
+        .unwrap_or_else(|| target_level.level_name.trim().is_empty());
+    if should_auto_name_level {
+        let naming =
+            generate_puzzle_first_level_name(state, target_level.picture_description.as_str())
+                .await;
+        target_level.level_name = naming.level_name.clone();
+        target_level.ui_background_prompt = naming.ui_background_prompt.clone();
+    }
+    let reference_image_sources = collect_puzzle_reference_image_sources(
+        payload.reference_image_src.as_deref(),
+        payload.reference_image_srcs.as_slice(),
+        payload.reference_image_asset_object_id.as_deref(),
+        payload.reference_image_asset_object_ids.as_slice(),
+    );
+    let primary_reference_image_src = reference_image_sources.first().map(String::as_str);
+    // 中文注释：拼图结果页从多候选抽卡收口为单图替换，前端传入的旧 candidateCount 只做兼容忽略。
+    let candidate_start_index = target_level.candidates.len();
+    let ai_redraw = payload.ai_redraw.unwrap_or(true);
+    let mut candidates =
+        if should_use_uploaded_puzzle_image_directly(primary_reference_image_src, ai_redraw) {
+            vec![
+                create_uploaded_puzzle_image_candidate(
+                    state,
+                    payload.owner_user_id.as_str(),
+                    &session.session_id,
+                    &target_level.level_name,
+                    &prompt,
+                    primary_reference_image_src.expect("checked reference image"),
+                    candidate_start_index,
+                )
+                .await?,
+            ]
+        } else {
+            let (_, profile_id) = build_stable_puzzle_work_ids(&session.session_id);
+            generate_puzzle_image_candidates(
+                state,
+                payload.owner_user_id.as_str(),
+                Some(profile_id.as_str()),
+                &session.session_id,
+                &target_level.level_name,
+                &prompt,
+                primary_reference_image_src,
+                ai_redraw,
+                payload.image_model.as_deref(),
+                1,
+                candidate_start_index,
+            )
+            .await
+            .map_err(map_puzzle_generation_endpoint_error)?
+        };
+    if candidates.is_empty() {
+        return Err(
+            AppError::from_status(StatusCode::BAD_GATEWAY).with_details(json!({
+                "provider": PUZZLE_AGENT_API_BASE_PROVIDER,
+                "message": "拼图候选图生成结果为空",
+            })),
+        );
+    }
+    if let Some(refined_naming) = generate_puzzle_first_level_name_from_image(
+        state,
+        target_level.picture_description.as_str(),
+        &candidates[0].downloaded_image,
+    )
+    .await
+    .filter(|_| should_auto_name_level)
+    {
+        target_level.level_name = refined_naming.level_name.clone();
+        if refined_naming.ui_background_prompt.is_some() {
+            target_level.ui_background_prompt = refined_naming.ui_background_prompt.clone();
+        }
+    }
+    let mut updated_levels =
+        build_puzzle_levels_with_primary_update(&draft, &target_level, primary_reference_image_src);
+    for candidate in &mut candidates {
+        candidate.record.prompt = prompt.clone();
+    }
+    let selected_candidate = candidates
+        .iter()
+        .find(|candidate| candidate.record.selected)
+        .or_else(|| candidates.first())
+        .ok_or_else(|| {
+            AppError::from_status(StatusCode::BAD_GATEWAY).with_details(json!({
+                "provider": PUZZLE_AGENT_API_BASE_PROVIDER,
+                "message": "拼图候选图生成结果为空",
+            }))
+        })?;
+    let asset_bundle = generate_puzzle_level_asset_bundle_required(
+        state,
+        request_context,
+        payload.owner_user_id.as_str(),
+        &session.session_id,
+        &target_level,
+        &selected_candidate.downloaded_image,
+    )
+    .await?;
+    attach_puzzle_level_asset_bundle(
+        &mut updated_levels,
+        target_level.level_id.as_str(),
+        asset_bundle,
+    );
+    attach_selected_puzzle_candidate_to_levels(
+        &mut updated_levels,
+        target_level.level_id.as_str(),
+        &selected_candidate.record,
+    );
+    let levels_json_with_generated_name =
+        Some(serialize_puzzle_level_records_for_module(&updated_levels)?);
+    let candidates_json = serde_json::to_string(
+        &candidates
+            .iter()
+            .map(|candidate| to_puzzle_generated_image_candidate(&candidate.record))
+            .collect::<Vec<_>>(),
+    )
+    .map_err(|error| {
+        AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
+            "provider": PUZZLE_AGENT_API_BASE_PROVIDER,
+            "message": format!("拼图候选图序列化失败：{error}"),
+        }))
+    })?;
+    state
+        .spacetime_client()
+        .save_puzzle_generated_images(PuzzleGeneratedImagesSaveRecordInput {
+            session_id: session.session_id.clone(),
+            owner_user_id: payload.owner_user_id.clone(),
+            level_id: Some(target_level.level_id.clone()),
+            levels_json: levels_json_with_generated_name,
+            candidates_json,
+            saved_at_micros: now,
+            external_generation_job_id: external_generation_guard.job_id.clone(),
+            external_generation_worker_id: external_generation_guard.worker_id.clone(),
+            external_generation_lease_token: external_generation_guard.lease_token.clone(),
+        })
+        .await
+        .map_err(map_puzzle_client_error)
+}
+
+async fn execute_puzzle_generate_ui_background_worker_job_inner(
+    state: &PuzzleApiState,
+    request_context: &RequestContext,
+    payload: &PuzzleGenerateUiBackgroundWorkerPayload,
+    now: i64,
+    external_generation_guard: &ExternalGenerationWriteLeaseGuard,
+) -> Result<PuzzleAgentSessionRecord, AppError> {
+    let action_payload = payload.to_action_request();
+    let target_level_id = payload.level_id.clone();
+    let levels_json = payload.levels_json.clone();
+    let session = get_puzzle_session_for_image_generation(
+        state,
+        payload.session_id.clone(),
+        payload.owner_user_id.clone(),
+        &action_payload,
+        levels_json.as_deref(),
+        now,
+    )
+    .await?;
+    let mut draft = session.draft.clone().ok_or_else(|| {
+        AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
+            "provider": PUZZLE_AGENT_API_BASE_PROVIDER,
+            "message": "拼图结果页草稿尚未生成",
+        }))
+    })?;
+    if let Some(levels_json) = levels_json.as_ref() {
+        draft.levels = parse_puzzle_level_records_from_module_json(levels_json)?;
+    }
+    let target_level = select_puzzle_level_for_api(&draft, target_level_id.as_deref())?;
+    let raw_prompt = payload
+        .prompt_text
+        .as_deref()
+        .map(str::trim)
+        .filter(|value| !value.is_empty())
+        .unwrap_or_default()
+        .to_string();
+    let resolved_prompt =
+        normalize_puzzle_ui_background_prompt(raw_prompt.as_str(), &draft, &target_level);
+    let generated = generate_puzzle_ui_background_image(
+        state,
+        request_context,
+        payload.owner_user_id.as_str(),
+        &session.session_id,
+        &target_level.level_name,
+        resolved_prompt.as_str(),
+    )
+    .await
+    .map_err(map_puzzle_generation_endpoint_error)?;
+    state
+        .spacetime_client()
+        .save_puzzle_ui_background(PuzzleUiBackgroundSaveRecordInput {
+            session_id: session.session_id.clone(),
+            owner_user_id: payload.owner_user_id.clone(),
+            level_id: Some(target_level.level_id.clone()),
+            levels_json,
+            prompt: resolved_prompt.clone(),
+            image_src: generated.image_src.clone(),
+            image_object_key: Some(generated.object_key.clone()),
+            saved_at_micros: now,
+            external_generation_job_id: external_generation_guard.job_id.clone(),
+            external_generation_worker_id: external_generation_guard.worker_id.clone(),
+            external_generation_lease_token: external_generation_guard.lease_token.clone(),
+        })
+        .await
+        .map_err(map_puzzle_client_error)
+}
+
+pub(crate) async fn mark_puzzle_level_generation_failure_for_worker(
+    state: &PuzzleApiState,
+    payload: &PuzzleGenerateImagesWorkerPayload,
+    error_message: String,
+    failed_at_micros: i64,
+    external_generation_guard: &ExternalGenerationWriteLeaseGuard,
+) -> Result<(), AppError> {
+    mark_puzzle_level_generation_failure_for_external_generation(
+        state,
+        &payload.session_id,
+        &payload.owner_user_id,
+        payload.level_id.clone(),
+        payload.levels_json.clone(),
+        error_message,
+        failed_at_micros,
+        external_generation_guard,
+    )
+    .await
+}
+
+async fn mark_puzzle_level_generation_failure_for_external_generation(
+    state: &PuzzleApiState,
+    session_id: &str,
+    owner_user_id: &str,
+    level_id: Option<String>,
+    levels_json: Option<String>,
+    error_message: String,
+    failed_at_micros: i64,
+    external_generation_guard: &ExternalGenerationWriteLeaseGuard,
+) -> Result<(), AppError> {
+    let result = state
+        .spacetime_client()
+        .mark_puzzle_level_generation_failed(PuzzleLevelGenerationFailureRecordInput {
+            session_id: session_id.to_string(),
+            owner_user_id: owner_user_id.to_string(),
+            level_id,
+            levels_json,
+            error_message,
+            failed_at_micros,
+            external_generation_job_id: external_generation_guard.job_id.clone(),
+            external_generation_worker_id: external_generation_guard.worker_id.clone(),
+            external_generation_lease_token: external_generation_guard.lease_token.clone(),
+        })
+        .await;
+    if let Err(error) = result {
+        tracing::warn!(
+            provider = PUZZLE_AGENT_API_BASE_PROVIDER,
+            session_id = %session_id,
+            owner_user_id = %owner_user_id,
+            message = %error,
+            "拼图 worker 关卡生图失败态回写失败"
+        );
+        return Err(map_puzzle_client_error(error));
+    }
+
+    Ok(())
+}
+
 pub(crate) async fn create_uploaded_puzzle_image_candidate(
     state: &PuzzleApiState,
     owner_user_id: &str,

server-rs/crates/api-server/src/puzzle/handlers.rs

@@ -609,35 +609,6 @@ pub async fn execute_puzzle_agent_action(
         "拼图 Agent action 开始执行"
     );
 
-    let mark_puzzle_compile_failure = |error: &AppError, compile_session_id: &str| {
-        let state = state.clone();
-        let owner_user_id = owner_user_id.clone();
-        let error_message = error.body_text();
-        let session_id = compile_session_id.to_string();
-        let log_session_id = session_id.clone();
-        let log_owner_user_id = owner_user_id.clone();
-        async move {
-            let result = state
-                .spacetime_client()
-                .mark_puzzle_draft_generation_failed(PuzzleDraftCompileFailureRecordInput {
-                    session_id,
-                    owner_user_id,
-                    error_message,
-                    failed_at_micros: now,
-                })
-                .await;
-            if let Err(error) = result {
-                tracing::warn!(
-                    provider = PUZZLE_AGENT_API_BASE_PROVIDER,
-                    session_id = %log_session_id,
-                    owner_user_id = %log_owner_user_id,
-                    message = %error,
-                    "拼图草稿失败态回写失败，继续返回原始错误"
-                );
-            }
-        }
-    };
-
     let (operation_type, phase_label, phase_detail, session) = match action.as_str() {
         "compile_puzzle_draft" => {
             let ai_redraw = payload.ai_redraw.unwrap_or(true);
@@ -667,61 +638,88 @@ pub async fn execute_puzzle_agent_action(
                 Ok(next_session_id) => next_session_id,
                 Err(response) => return Err(response),
             };
-            let session = if ai_redraw {
-                execute_billable_asset_operation_with_cost(
-                    state.root_state(),
-                    &owner_user_id,
-                    "puzzle_initial_image",
-                    &billing_asset_id,
-                    PUZZLE_IMAGE_GENERATION_POINTS_COST,
-                    async {
-                        compile_puzzle_draft_with_initial_cover(
-                            &state,
-                            &request_context,
-                            compile_session_id.clone(),
-                            owner_user_id.clone(),
-                            prompt_text,
-                            primary_reference_image_src,
-                            payload.image_model.as_deref(),
-                            now,
-                        )
-                        .await
-                    },
-                )
-                .await
-            } else {
-                compile_puzzle_draft_with_uploaded_cover(
-                    &state,
-                    &request_context,
-                    compile_session_id.clone(),
-                    owner_user_id.clone(),
-                    prompt_text,
-                    primary_reference_image_src,
-                    now,
-                )
-                .await
+            let worker_payload = PuzzleCompileDraftWorkerPayload {
+                session_id: compile_session_id.clone(),
+                owner_user_id: owner_user_id.clone(),
+                billing_asset_id: billing_asset_id.clone(),
+                ai_redraw,
+                prompt_text: prompt_text.map(ToOwned::to_owned),
+                reference_image_src: primary_reference_image_src.map(ToOwned::to_owned),
+                image_model: payload.image_model.clone(),
+                requested_at_micros: now,
             };
-            let session = match session {
-                Ok(session) => Ok(session),
-                Err(error) => {
-                    mark_puzzle_compile_failure(&error, &compile_session_id).await;
-                    Err(puzzle_error_response(
+            let request_payload_json = serde_json::to_string(&worker_payload).map_err(|error| {
+                puzzle_error_response(
+                    &request_context,
+                    PUZZLE_AGENT_API_BASE_PROVIDER,
+                    AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
+                        "provider": PUZZLE_AGENT_API_BASE_PROVIDER,
+                        "message": format!("拼图生成任务参数序列化失败：{error}"),
+                    })),
+                )
+            })?;
+            let external_generation_job_id = build_prefixed_uuid_id("extgen-");
+            let job = state
+                .spacetime_client()
+                .enqueue_external_generation_job(ExternalGenerationJobEnqueueRecordInput {
+                    job_id: external_generation_job_id.clone(),
+                    dedupe_key: format!(
+                        "puzzle:compile_puzzle_draft:{compile_session_id}:{external_generation_job_id}"
+                    ),
+                    job_kind: PUZZLE_COMPILE_DRAFT_JOB_KIND.to_string(),
+                    owner_user_id: owner_user_id.clone(),
+                    source_module: "puzzle".to_string(),
+                    source_entity_id: compile_session_id.clone(),
+                    request_label: "拼图首关草稿生成".to_string(),
+                    request_payload_json,
+                    max_attempts: 1,
+                    available_at_micros: now,
+                    created_at_micros: now,
+                })
+                .await
+                .map_err(|error| {
+                    puzzle_error_response(
                         &request_context,
                         PUZZLE_AGENT_API_BASE_PROVIDER,
-                        error,
-                    ))
-                }
+                        map_puzzle_client_error(error),
+                    )
+                })?;
+            let session = state
+                .spacetime_client()
+                .get_puzzle_agent_session(compile_session_id.clone(), owner_user_id.clone())
+                .await
+                .map_err(|error| {
+                    puzzle_error_response(
+                        &request_context,
+                        PUZZLE_AGENT_API_BASE_PROVIDER,
+                        map_puzzle_client_error(error),
+                    )
+                })?;
+            let (status, progress) = match job.status.as_str() {
+                "completed" => ("completed", 100),
+                "running" => ("running", session.progress_percent.max(10)),
+                "failed" => ("failed", session.progress_percent),
+                _ => ("queued", session.progress_percent.max(5)),
             };
-            (
-                "compile_puzzle_draft",
-                "首关拼图草稿",
-                if ai_redraw {
-                    "已编译首关草稿、并行生成首关画面和 UI 背景并写入正式草稿。"
-                } else {
-                    "已编译首关草稿，并直接应用上传图片、生成 UI 背景为第一关图片。"
+            return Ok(json_success_body(
+                Some(&request_context),
+                PuzzleAgentActionResponse {
+                    operation: PuzzleAgentOperationResponse {
+                        operation_id: job.job_id,
+                        operation_type: "compile_puzzle_draft".to_string(),
+                        status: status.to_string(),
+                        phase_label: "首关拼图草稿".to_string(),
+                        phase_detail: if ai_redraw {
+                            "首关草稿生成已进入后台队列。".to_string()
+                        } else {
+                            "首关草稿编译已进入后台队列。".to_string()
+                        },
+                        progress,
+                        error: job.last_error_message,
+                    },
+                    session: map_puzzle_agent_session_response(session),
                 },
-                session,
-            )
+            ));
         }
         "save_puzzle_form_draft" => {
             let seed_text = build_puzzle_form_seed_text_from_parts(
@@ -783,367 +781,205 @@ pub async fn execute_puzzle_agent_action(
                 payload.levels_json.as_deref(),
             )
             .map_err(|message| {
-                AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
-                    "provider": PUZZLE_AGENT_API_BASE_PROVIDER,
-                    "message": message,
-                }))
-            });
-            let session = execute_billable_asset_operation_with_cost(
-                state.root_state(),
-                &owner_user_id,
-                "puzzle_generated_image",
-                &billing_asset_id,
-                PUZZLE_IMAGE_GENERATION_POINTS_COST,
-                async {
-                    let levels_json = levels_json?;
-                    let session = get_puzzle_session_for_image_generation(
-                        &state,
-                        session_id.clone(),
-                        owner_user_id.clone(),
-                        &payload,
-                        levels_json.as_deref(),
-                        now,
-                    )
-                    .await?;
-                    let mut draft = session.draft.clone().ok_or_else(|| {
-                        AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
-                            "provider": PUZZLE_AGENT_API_BASE_PROVIDER,
-                            "message": "拼图结果页草稿尚未生成",
-                        }))
-                    })?;
-                    if let Some(levels_json) = levels_json.as_ref() {
-                        draft.levels = parse_puzzle_level_records_from_module_json(levels_json)?;
-                    }
-                    let mut target_level =
-                        select_puzzle_level_for_api(&draft, target_level_id.as_deref())?;
-                    let fallback_level_name = target_level.level_name.clone();
-                    let prompt = resolve_puzzle_level_image_prompt(
-                        payload.prompt_text.as_deref(),
-                        &target_level.picture_description,
-                        &draft.summary,
-                    );
-                    let should_auto_name_level = payload
-                        .should_auto_name_level
-                        .unwrap_or_else(|| target_level.level_name.trim().is_empty());
-                    let mut generated_naming = if should_auto_name_level {
-                        let naming = generate_puzzle_first_level_name(
-                            &state,
-                            target_level.picture_description.as_str(),
-                        )
-                        .await;
-                        target_level.level_name = naming.level_name.clone();
-                        target_level.ui_background_prompt = naming.ui_background_prompt.clone();
-                        Some(naming)
-                    } else {
-                        None
-                    };
-                    let reference_image_sources = collect_puzzle_reference_image_sources(
-                        payload.reference_image_src.as_deref(),
-                        payload.reference_image_srcs.as_slice(),
-                        payload.reference_image_asset_object_id.as_deref(),
-                        payload.reference_image_asset_object_ids.as_slice(),
-                    );
-                    let primary_reference_image_src =
-                        reference_image_sources.first().map(String::as_str);
-                    // 拼图结果页从多候选抽卡收口为单图替换，前端传入的旧 candidateCount 只做兼容忽略。
-                    let candidate_start_index = target_level.candidates.len();
-                    let ai_redraw = payload.ai_redraw.unwrap_or(true);
-                    let mut candidates = if should_use_uploaded_puzzle_image_directly(
-                        primary_reference_image_src,
-                        ai_redraw,
-                    ) {
-                        vec![
-                            create_uploaded_puzzle_image_candidate(
-                                &state,
-                                owner_user_id.as_str(),
-                                &session.session_id,
-                                &target_level.level_name,
-                                &prompt,
-                                primary_reference_image_src.expect("checked reference image"),
-                                candidate_start_index,
-                            )
-                            .await?,
-                        ]
-                    } else {
-                        let (_, profile_id) = build_stable_puzzle_work_ids(&session.session_id);
-                        generate_puzzle_image_candidates(
-                            &state,
-                            owner_user_id.as_str(),
-                            Some(profile_id.as_str()),
-                            &session.session_id,
-                            &target_level.level_name,
-                            &prompt,
-                            primary_reference_image_src,
-                            ai_redraw,
-                            payload.image_model.as_deref(),
-                            1,
-                            candidate_start_index,
-                        )
-                        .await
-                        .map_err(map_puzzle_generation_endpoint_error)?
-                    };
-                    if candidates.is_empty() {
-                        return Err(AppError::from_status(StatusCode::BAD_GATEWAY).with_details(
-                            json!({
-                                "provider": PUZZLE_AGENT_API_BASE_PROVIDER,
-                                "message": "拼图候选图生成结果为空",
-                            }),
-                        ));
-                    }
-                    if let Some(refined_naming) = generate_puzzle_first_level_name_from_image(
-                        &state,
-                        target_level.picture_description.as_str(),
-                        &candidates[0].downloaded_image,
-                    )
-                    .await
-                    .filter(|_| should_auto_name_level)
-                    {
-                        target_level.level_name = refined_naming.level_name.clone();
-                        if refined_naming.ui_background_prompt.is_some() {
-                            target_level.ui_background_prompt =
-                                refined_naming.ui_background_prompt.clone();
-                        }
-                        generated_naming = Some(refined_naming);
-                    }
-                    let generated_level_name = target_level.level_name.clone();
-                    let mut updated_levels = build_puzzle_levels_with_primary_update(
-                        &draft,
-                        &target_level,
-                        primary_reference_image_src,
-                    );
-                    for candidate in &mut candidates {
-                        candidate.record.prompt = prompt.clone();
-                    }
-                    let selected_candidate = candidates
-                        .iter()
-                        .find(|candidate| candidate.record.selected)
-                        .or_else(|| candidates.first())
-                        .ok_or_else(|| {
-                            AppError::from_status(StatusCode::BAD_GATEWAY).with_details(json!({
-                                "provider": PUZZLE_AGENT_API_BASE_PROVIDER,
-                                "message": "拼图候选图生成结果为空",
-                            }))
-                        })?;
-                    let asset_bundle = generate_puzzle_level_asset_bundle_required(
-                        &state,
+                puzzle_error_response(
+                    &request_context,
+                    PUZZLE_AGENT_API_BASE_PROVIDER,
+                    AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
+                        "provider": PUZZLE_AGENT_API_BASE_PROVIDER,
+                        "message": message,
+                    })),
+                )
+            })?;
+            let worker_payload = PuzzleGenerateImagesWorkerPayload {
+                session_id: session_id.clone(),
+                owner_user_id: owner_user_id.clone(),
+                billing_asset_id: billing_asset_id.clone(),
+                level_id: target_level_id.clone(),
+                prompt_text: payload.prompt_text.clone(),
+                reference_image_src: payload.reference_image_src.clone(),
+                reference_image_srcs: payload.reference_image_srcs.clone(),
+                reference_image_asset_object_id: payload.reference_image_asset_object_id.clone(),
+                reference_image_asset_object_ids: payload.reference_image_asset_object_ids.clone(),
+                image_model: payload.image_model.clone(),
+                ai_redraw: payload.ai_redraw,
+                should_auto_name_level: payload.should_auto_name_level,
+                work_title: payload.work_title.clone(),
+                work_description: payload.work_description.clone(),
+                picture_description: payload.picture_description.clone(),
+                summary: payload.summary.clone(),
+                theme_tags: payload.theme_tags.clone(),
+                levels_json,
+                requested_at_micros: now,
+            };
+            let request_payload_json = serde_json::to_string(&worker_payload).map_err(|error| {
+                puzzle_error_response(
+                    &request_context,
+                    PUZZLE_AGENT_API_BASE_PROVIDER,
+                    AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
+                        "provider": PUZZLE_AGENT_API_BASE_PROVIDER,
+                        "message": format!("拼图关卡图片生成任务参数序列化失败：{error}"),
+                    })),
+                )
+            })?;
+            let external_generation_job_id = build_prefixed_uuid_id("extgen-");
+            let source_entity_id = target_level_id
+                .as_deref()
+                .map(|level_id| format!("{session_id}:{level_id}"))
+                .unwrap_or_else(|| session_id.clone());
+            let job = state
+                .spacetime_client()
+                .enqueue_external_generation_job(ExternalGenerationJobEnqueueRecordInput {
+                    job_id: external_generation_job_id.clone(),
+                    dedupe_key: format!(
+                        "puzzle:generate_puzzle_images:{session_id}:{external_generation_job_id}"
+                    ),
+                    job_kind: PUZZLE_GENERATE_IMAGES_JOB_KIND.to_string(),
+                    owner_user_id: owner_user_id.clone(),
+                    source_module: "puzzle".to_string(),
+                    source_entity_id,
+                    request_label: "拼图关卡图片生成".to_string(),
+                    request_payload_json,
+                    max_attempts: 1,
+                    available_at_micros: now,
+                    created_at_micros: now,
+                })
+                .await
+                .map_err(|error| {
+                    puzzle_error_response(
                         &request_context,
-                        owner_user_id.as_str(),
-                        &session.session_id,
-                        &target_level,
-                        &selected_candidate.downloaded_image,
+                        PUZZLE_AGENT_API_BASE_PROVIDER,
+                        map_puzzle_client_error(error),
                     )
-                    .await?;
-                    attach_puzzle_level_asset_bundle(
-                        &mut updated_levels,
-                        target_level.level_id.as_str(),
-                        asset_bundle,
-                    );
-                    attach_selected_puzzle_candidate_to_levels(
-                        &mut updated_levels,
-                        target_level.level_id.as_str(),
-                        &selected_candidate.record,
-                    );
-                    let levels_json_with_generated_name =
-                        Some(serialize_puzzle_level_records_for_module(&updated_levels)?);
-                    let candidates_json = serde_json::to_string(
-                        &candidates
-                            .iter()
-                            .map(|candidate| to_puzzle_generated_image_candidate(&candidate.record))
-                            .collect::<Vec<_>>(),
+                })?;
+            let session = state
+                .spacetime_client()
+                .get_puzzle_agent_session(session_id.clone(), owner_user_id.clone())
+                .await
+                .map_err(|error| {
+                    puzzle_error_response(
+                        &request_context,
+                        PUZZLE_AGENT_API_BASE_PROVIDER,
+                        map_puzzle_client_error(error),
                     )
-                    .map_err(|error| {
-                        AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
-                            "provider": PUZZLE_AGENT_API_BASE_PROVIDER,
-                            "message": format!("拼图候选图序列化失败：{error}"),
-                        }))
-                    })?;
-                    let save_result = state
-                        .spacetime_client()
-                        .save_puzzle_generated_images(PuzzleGeneratedImagesSaveRecordInput {
-                            session_id: session.session_id.clone(),
-                            owner_user_id: owner_user_id.clone(),
-                            level_id: Some(target_level.level_id.clone()),
-                            levels_json: levels_json_with_generated_name,
-                            candidates_json,
-                            saved_at_micros: now,
-                        })
-                        .await;
-                    match save_result {
-                        Ok(session) => Ok(session),
-                        Err(error)
-                            if should_skip_asset_operation_billing_for_connectivity(&error) =>
-                        {
-                            // 中文注释：VectorEngine/OSS 已生成真实图片时，SpacetimeDB 短暂 503 不应让前端看不到本次图片；先返回内存合成快照，待后续操作恢复正常持久化。
-                            tracing::warn!(
-                                provider = PUZZLE_AGENT_API_BASE_PROVIDER,
-                                session_id = %session.session_id,
-                                owner_user_id = %owner_user_id,
-                                error = %error,
-                                "拼图图片已生成但 SpacetimeDB 草稿回写不可用，降级返回本次生成快照"
-                            );
-                            let fallback_session =
-                                replace_puzzle_session_draft_snapshot(session, draft, now);
-                            let fallback_session = if should_auto_name_level {
-                                apply_generated_puzzle_first_level_name_to_session_snapshot(
-                                    fallback_session,
-                                    target_level.level_id.as_str(),
-                                    generated_level_name.as_str(),
-                                    fallback_level_name.as_str(),
-                                    now,
-                                )
-                            } else {
-                                fallback_session
-                            };
-                            let mut fallback_session =
-                                apply_generated_puzzle_candidates_to_session_snapshot(
-                                    apply_generated_puzzle_levels_to_session_snapshot(
-                                        fallback_session,
-                                        updated_levels,
-                                        now,
-                                    ),
-                                    target_level.level_id.as_str(),
-                                    candidates.into_records(),
-                                    primary_reference_image_src,
-                                    now,
-                                );
-                            if let Some(generated_naming) = generated_naming.as_ref() {
-                                fallback_session =
-                                    apply_generated_puzzle_metadata_to_session_snapshot(
-                                        fallback_session,
-                                        target_level.level_id.as_str(),
-                                        generated_naming,
-                                        fallback_level_name.as_str(),
-                                        now,
-                                    );
-                            }
-                            Ok(fallback_session)
-                        }
-                        Err(error) => Err(map_puzzle_client_error(error)),
-                    }
+                })?;
+            let (status, progress) = match job.status.as_str() {
+                "completed" => ("completed", 100),
+                "running" => ("running", 35),
+                "failed" => ("failed", 0),
+                _ => ("queued", 8),
+            };
+            return Ok(json_success_body(
+                Some(&request_context),
+                PuzzleAgentActionResponse {
+                    operation: PuzzleAgentOperationResponse {
+                        operation_id: job.job_id,
+                        operation_type: "generate_puzzle_images".to_string(),
+                        status: status.to_string(),
+                        phase_label: "拼图图片生成".to_string(),
+                        phase_detail: "关卡图片生成已进入后台队列。".to_string(),
+                        progress,
+                        error: job.last_error_message,
+                    },
+                    session: map_puzzle_agent_session_response(session),
                 },
-            )
-            .await
-            .map_err(|error| {
-                puzzle_error_response(&request_context, PUZZLE_AGENT_API_BASE_PROVIDER, error)
-            });
-            (
-                "generate_puzzle_images",
-                "拼图图片生成",
-                "已生成并替换当前拼图图片。",
-                session,
-            )
+            ));
         }
         "generate_puzzle_ui_background" => {
             let target_level_id = payload.level_id.clone();
-            let raw_prompt = payload
-                .prompt_text
-                .as_deref()
-                .map(str::trim)
-                .filter(|value| !value.is_empty())
-                .unwrap_or_default()
-                .to_string();
             let levels_json = normalize_puzzle_levels_json_for_module(
                 payload.levels_json.as_deref(),
             )
             .map_err(|message| {
-                AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
-                    "provider": PUZZLE_AGENT_API_BASE_PROVIDER,
-                    "message": message,
-                }))
-            });
-            let session = execute_billable_asset_operation_with_cost(
-                state.root_state(),
-                &owner_user_id,
-                "puzzle_ui_background_image",
-                &billing_asset_id,
-                PUZZLE_IMAGE_GENERATION_POINTS_COST,
-                async {
-                    let levels_json = levels_json?;
-                    let session = get_puzzle_session_for_image_generation(
-                        &state,
-                        session_id.clone(),
-                        owner_user_id.clone(),
-                        &payload,
-                        levels_json.as_deref(),
-                        now,
-                    )
-                    .await?;
-                    let mut draft = session.draft.clone().ok_or_else(|| {
-                        AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
-                            "provider": PUZZLE_AGENT_API_BASE_PROVIDER,
-                            "message": "拼图结果页草稿尚未生成",
-                        }))
-                    })?;
-                    if let Some(levels_json) = levels_json.as_ref() {
-                        draft.levels = parse_puzzle_level_records_from_module_json(levels_json)?;
-                    }
-                    let target_level =
-                        select_puzzle_level_for_api(&draft, target_level_id.as_deref())?;
-                    let resolved_prompt = normalize_puzzle_ui_background_prompt(
-                        raw_prompt.as_str(),
-                        &draft,
-                        &target_level,
-                    );
-                    let generated = generate_puzzle_ui_background_image(
-                        &state,
+                puzzle_error_response(
+                    &request_context,
+                    PUZZLE_AGENT_API_BASE_PROVIDER,
+                    AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
+                        "provider": PUZZLE_AGENT_API_BASE_PROVIDER,
+                        "message": message,
+                    })),
+                )
+            })?;
+            let worker_payload = PuzzleGenerateUiBackgroundWorkerPayload {
+                session_id: session_id.clone(),
+                owner_user_id: owner_user_id.clone(),
+                billing_asset_id: billing_asset_id.clone(),
+                level_id: target_level_id.clone(),
+                prompt_text: payload.prompt_text.clone(),
+                levels_json,
+                requested_at_micros: now,
+            };
+            let request_payload_json = serde_json::to_string(&worker_payload).map_err(|error| {
+                puzzle_error_response(
+                    &request_context,
+                    PUZZLE_AGENT_API_BASE_PROVIDER,
+                    AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
+                        "provider": PUZZLE_AGENT_API_BASE_PROVIDER,
+                        "message": format!("拼图 UI 背景图生成任务参数序列化失败：{error}"),
+                    })),
+                )
+            })?;
+            let external_generation_job_id = build_prefixed_uuid_id("extgen-");
+            let source_entity_id = target_level_id
+                .as_deref()
+                .map(|level_id| format!("{session_id}:{level_id}"))
+                .unwrap_or_else(|| session_id.clone());
+            let job = state
+                .spacetime_client()
+                .enqueue_external_generation_job(ExternalGenerationJobEnqueueRecordInput {
+                    job_id: external_generation_job_id.clone(),
+                    dedupe_key: format!(
+                        "puzzle:generate_puzzle_ui_background:{session_id}:{external_generation_job_id}"
+                    ),
+                    job_kind: PUZZLE_GENERATE_UI_BACKGROUND_JOB_KIND.to_string(),
+                    owner_user_id: owner_user_id.clone(),
+                    source_module: "puzzle".to_string(),
+                    source_entity_id,
+                    request_label: "拼图 UI 背景图生成".to_string(),
+                    request_payload_json,
+                    max_attempts: 1,
+                    available_at_micros: now,
+                    created_at_micros: now,
+                })
+                .await
+                .map_err(|error| {
+                    puzzle_error_response(
                         &request_context,
-                        owner_user_id.as_str(),
-                        &session.session_id,
-                        &target_level.level_name,
-                        resolved_prompt.as_str(),
+                        PUZZLE_AGENT_API_BASE_PROVIDER,
+                        map_puzzle_client_error(error),
                     )
-                    .await
-                    .map_err(map_puzzle_generation_endpoint_error)?;
-                    let save_result = state
-                        .spacetime_client()
-                        .save_puzzle_ui_background(PuzzleUiBackgroundSaveRecordInput {
-                            session_id: session.session_id.clone(),
-                            owner_user_id: owner_user_id.clone(),
-                            level_id: Some(target_level.level_id.clone()),
-                            levels_json,
-                            prompt: resolved_prompt.clone(),
-                            image_src: generated.image_src.clone(),
-                            image_object_key: Some(generated.object_key.clone()),
-                            saved_at_micros: now,
-                        })
-                        .await;
-                    match save_result {
-                        Ok(session) => Ok(session),
-                        Err(error)
-                            if should_skip_asset_operation_billing_for_connectivity(&error) =>
-                        {
-                            tracing::warn!(
-                                provider = PUZZLE_AGENT_API_BASE_PROVIDER,
-                                session_id = %session.session_id,
-                                owner_user_id = %owner_user_id,
-                                error = %error,
-                                "拼图 UI 背景图已生成但 SpacetimeDB 草稿回写不可用，降级返回本次生成快照"
-                            );
-                            let fallback_session =
-                                replace_puzzle_session_draft_snapshot(session, draft, now);
-                            Ok(apply_generated_puzzle_ui_background_to_session_snapshot(
-                                fallback_session,
-                                target_level.level_id.as_str(),
-                                resolved_prompt,
-                                generated.image_src,
-                                Some(generated.object_key),
-                                now,
-                            ))
-                        }
-                        Err(error) => Err(map_puzzle_client_error(error)),
-                    }
+                })?;
+            let session = state
+                .spacetime_client()
+                .get_puzzle_agent_session(session_id.clone(), owner_user_id.clone())
+                .await
+                .map_err(|error| {
+                    puzzle_error_response(
+                        &request_context,
+                        PUZZLE_AGENT_API_BASE_PROVIDER,
+                        map_puzzle_client_error(error),
+                    )
+                })?;
+            let (status, progress) = match job.status.as_str() {
+                "completed" => ("completed", 100),
+                "running" => ("running", session.progress_percent.max(55)),
+                "failed" => ("failed", session.progress_percent),
+                _ => ("queued", session.progress_percent.max(12)),
+            };
+            return Ok(json_success_body(
+                Some(&request_context),
+                PuzzleAgentActionResponse {
+                    operation: PuzzleAgentOperationResponse {
+                        operation_id: job.job_id,
+                        operation_type: "generate_puzzle_ui_background".to_string(),
+                        status: status.to_string(),
+                        phase_label: "UI 背景图生成".to_string(),
+                        phase_detail: "拼图 UI 背景图生成已进入后台队列。".to_string(),
+                        progress,
+                        error: job.last_error_message,
+                    },
+                    session: map_puzzle_agent_session_response(session),
                 },
-            )
-            .await
-            .map_err(|error| {
-                puzzle_error_response(&request_context, PUZZLE_AGENT_API_BASE_PROVIDER, error)
-            });
-            (
-                "generate_puzzle_ui_background",
-                "UI 背景图生成",
-                "已生成拼图 UI 背景图。",
-                session,
-            )
+            ));
         }
         "generate_puzzle_tags" => {
             let work_title = payload

server-rs/crates/api-server/src/puzzle/tests.rs

@@ -484,6 +484,108 @@ fn puzzle_image_generation_builds_fallback_session_from_levels_snapshot() {
     );
 }
 
+#[test]
+fn puzzle_generate_images_worker_payload_keeps_action_snapshot() {
+    let raw_levels_json = serde_json::to_string(&vec![json!({
+        "levelId": "puzzle-level-2",
+        "levelName": "",
+        "pictureDescription": "新关卡里有一座发光钟楼。",
+        "candidates": [],
+        "selectedCandidateId": null,
+        "coverImageSrc": null,
+        "coverAssetId": null,
+        "generationStatus": "generating",
+    })])
+    .expect("levels json");
+    let levels_json = normalize_puzzle_levels_json_for_module(Some(raw_levels_json.as_str()))
+        .expect("levels should normalize")
+        .expect("levels json should exist");
+    let payload = PuzzleGenerateImagesWorkerPayload {
+        session_id: "puzzle-session-1".to_string(),
+        owner_user_id: "user-1".to_string(),
+        billing_asset_id: "puzzle-session-1:123".to_string(),
+        level_id: Some("puzzle-level-2".to_string()),
+        prompt_text: Some("发光钟楼".to_string()),
+        reference_image_src: None,
+        reference_image_srcs: vec!["data:image/png;base64,abc".to_string()],
+        reference_image_asset_object_id: Some("asset-object-1".to_string()),
+        reference_image_asset_object_ids: vec!["asset-object-2".to_string()],
+        image_model: Some(PUZZLE_IMAGE_MODEL_GPT_IMAGE_2.to_string()),
+        ai_redraw: Some(true),
+        should_auto_name_level: Some(true),
+        work_title: Some("暖灯猫街作品".to_string()),
+        work_description: Some("一套雨夜猫街主题拼图。".to_string()),
+        picture_description: None,
+        summary: Some("一套雨夜猫街主题拼图。".to_string()),
+        theme_tags: Some(vec!["猫咪".to_string(), "雨夜".to_string()]),
+        levels_json: Some(levels_json.clone()),
+        requested_at_micros: 123,
+    };
+
+    let encoded = serde_json::to_string(&payload).expect("payload should serialize");
+    let decoded: PuzzleGenerateImagesWorkerPayload =
+        serde_json::from_str(encoded.as_str()).expect("payload should deserialize");
+
+    assert_eq!(decoded.level_id.as_deref(), Some("puzzle-level-2"));
+    assert_eq!(decoded.reference_image_srcs.len(), 1);
+    assert_eq!(
+        decoded.reference_image_asset_object_ids,
+        vec!["asset-object-2".to_string()]
+    );
+    assert_eq!(decoded.should_auto_name_level, Some(true));
+    let records = parse_puzzle_level_records_from_module_json(
+        decoded.levels_json.as_deref().expect("levels json"),
+    )
+    .expect("levels should parse as module json");
+    assert_eq!(records[0].level_id, "puzzle-level-2");
+    assert_eq!(records[0].generation_status, "generating");
+}
+
+#[test]
+fn puzzle_generate_ui_background_worker_payload_keeps_action_snapshot() {
+    let raw_levels_json = serde_json::to_string(&vec![json!({
+        "levelId": "puzzle-level-3",
+        "levelName": "钟楼回廊",
+        "pictureDescription": "新关卡里有一座发光钟楼。",
+        "uiBackgroundPrompt": "发光钟楼延展成竖屏回廊，远处有暖色窗光。",
+        "candidates": [],
+        "selectedCandidateId": null,
+        "coverImageSrc": null,
+        "coverAssetId": null,
+        "generationStatus": "generating",
+    })])
+    .expect("levels json");
+    let levels_json = normalize_puzzle_levels_json_for_module(Some(raw_levels_json.as_str()))
+        .expect("levels should normalize")
+        .expect("levels json should exist");
+    let payload = PuzzleGenerateUiBackgroundWorkerPayload {
+        session_id: "puzzle-session-1".to_string(),
+        owner_user_id: "user-1".to_string(),
+        billing_asset_id: "puzzle-session-1:456".to_string(),
+        level_id: Some("puzzle-level-3".to_string()),
+        prompt_text: Some("发光钟楼延展成竖屏回廊".to_string()),
+        levels_json: Some(levels_json.clone()),
+        requested_at_micros: 456,
+    };
+
+    let encoded = serde_json::to_string(&payload).expect("payload should serialize");
+    let decoded: PuzzleGenerateUiBackgroundWorkerPayload =
+        serde_json::from_str(encoded.as_str()).expect("payload should deserialize");
+
+    assert_eq!(decoded.level_id.as_deref(), Some("puzzle-level-3"));
+    assert_eq!(
+        decoded.prompt_text.as_deref(),
+        Some("发光钟楼延展成竖屏回廊")
+    );
+    assert_eq!(decoded.requested_at_micros, 456);
+    let records = parse_puzzle_level_records_from_module_json(
+        decoded.levels_json.as_deref().expect("levels json"),
+    )
+    .expect("levels should parse as module json");
+    assert_eq!(records[0].level_id, "puzzle-level-3");
+    assert_eq!(records[0].generation_status, "generating");
+}
+
 #[test]
 fn puzzle_first_level_name_parser_accepts_json_and_normalizes_text() {
     assert_eq!(