1

2026-04-22 20:14:15 +08:00
parent 0773a0d0ca
commit 0e9c286a57
205 changed files with 25790 additions and 1623 deletions
--- a/server-rs/crates/api-server/src/big_fish.rs
+++ b/server-rs/crates/api-server/src/big_fish.rs
@@ -0,0 +1,653 @@
+use axum::{
+    Json,
+    extract::{Extension, Path, State, rejection::JsonRejection},
+    http::{HeaderName, StatusCode, header},
+    response::{IntoResponse, Response},
+};
+use serde_json::{Value, json};
+use shared_contracts::big_fish::{
+    BigFishActionResponse, BigFishAgentMessageResponse, BigFishAnchorItemResponse,
+    BigFishAnchorPackResponse, BigFishAssetCoverageResponse, BigFishAssetSlotResponse,
+    BigFishBackgroundBlueprintResponse, BigFishGameDraftResponse, BigFishLevelBlueprintResponse,
+    BigFishRuntimeEntityResponse, BigFishRuntimeParamsResponse, BigFishRuntimeSnapshotResponse,
+    BigFishRunResponse, BigFishSessionResponse, BigFishSessionSnapshotResponse,
+    BigFishVector2Response, CreateBigFishSessionRequest, ExecuteBigFishActionRequest,
+    SendBigFishMessageRequest, SubmitBigFishInputRequest,
+};
+use shared_kernel::build_prefixed_uuid_id;
+use spacetime_client::{
+    BigFishAgentMessageRecord, BigFishAnchorItemRecord, BigFishAnchorPackRecord,
+    BigFishAssetCoverageRecord, BigFishAssetGenerateRecordInput, BigFishAssetSlotRecord,
+    BigFishBackgroundBlueprintRecord, BigFishGameDraftRecord, BigFishLevelBlueprintRecord,
+    BigFishMessageSubmitRecordInput, BigFishRunInputSubmitRecordInput, BigFishRunStartRecordInput,
+    BigFishRuntimeEntityRecord, BigFishRuntimeParamsRecord, BigFishRuntimeRecord,
+    BigFishSessionCreateRecordInput, BigFishSessionRecord, BigFishVector2Record,
+    SpacetimeClientError,
+};
+
+use crate::{
+    api_response::json_success_body, auth::AuthenticatedAccessToken, http_error::AppError,
+    request_context::RequestContext, state::AppState,
+};
+
+pub async fn create_big_fish_session(
+    State(state): State<AppState>,
+    Extension(request_context): Extension<RequestContext>,
+    Extension(authenticated): Extension<AuthenticatedAccessToken>,
+    payload: Result<Json<CreateBigFishSessionRequest>, JsonRejection>,
+) -> Result<Json<Value>, Response> {
+    let Json(payload) = payload.map_err(|error| {
+        big_fish_error_response(
+            &request_context,
+            AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
+                "provider": "big-fish",
+                "message": error.body_text(),
+            })),
+        )
+    })?;
+
+    let seed_text = payload.seed_text.unwrap_or_default().trim().to_string();
+    let session = state
+        .spacetime_client()
+        .create_big_fish_session(BigFishSessionCreateRecordInput {
+            session_id: build_prefixed_uuid_id("big-fish-session-"),
+            owner_user_id: authenticated.claims().user_id().to_string(),
+            seed_text: seed_text.clone(),
+            welcome_message_id: build_prefixed_uuid_id("big-fish-message-"),
+            welcome_message_text: build_big_fish_welcome_text(&seed_text),
+            created_at_micros: current_utc_micros(),
+        })
+        .await
+        .map_err(|error| big_fish_error_response(&request_context, map_big_fish_client_error(error)))?;
+
+    Ok(json_success_body(
+        Some(&request_context),
+        BigFishSessionResponse {
+            session: map_big_fish_session_response(session),
+        },
+    ))
+}
+
+pub async fn get_big_fish_session(
+    State(state): State<AppState>,
+    Path(session_id): Path<String>,
+    Extension(request_context): Extension<RequestContext>,
+    Extension(authenticated): Extension<AuthenticatedAccessToken>,
+) -> Result<Json<Value>, Response> {
+    ensure_non_empty(&request_context, &session_id, "sessionId")?;
+
+    let session = state
+        .spacetime_client()
+        .get_big_fish_session(session_id, authenticated.claims().user_id().to_string())
+        .await
+        .map_err(|error| big_fish_error_response(&request_context, map_big_fish_client_error(error)))?;
+
+    Ok(json_success_body(
+        Some(&request_context),
+        BigFishSessionResponse {
+            session: map_big_fish_session_response(session),
+        },
+    ))
+}
+
+pub async fn submit_big_fish_message(
+    State(state): State<AppState>,
+    Path(session_id): Path<String>,
+    Extension(request_context): Extension<RequestContext>,
+    Extension(authenticated): Extension<AuthenticatedAccessToken>,
+    payload: Result<Json<SendBigFishMessageRequest>, JsonRejection>,
+) -> Result<Json<Value>, Response> {
+    let Json(payload) = payload.map_err(|error| {
+        big_fish_error_response(
+            &request_context,
+            AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
+                "provider": "big-fish",
+                "message": error.body_text(),
+            })),
+        )
+    })?;
+    ensure_non_empty(&request_context, &session_id, "sessionId")?;
+
+    let client_message_id = payload.client_message_id.trim().to_string();
+    let message_text = payload.text.trim().to_string();
+    if client_message_id.is_empty() || message_text.is_empty() {
+        return Err(big_fish_bad_request(
+            &request_context,
+            "clientMessageId and text are required",
+        ));
+    }
+
+    let session = state
+        .spacetime_client()
+        .submit_big_fish_message(BigFishMessageSubmitRecordInput {
+            session_id,
+            owner_user_id: authenticated.claims().user_id().to_string(),
+            user_message_id: client_message_id,
+            user_message_text: message_text,
+            assistant_message_id: build_prefixed_uuid_id("big-fish-message-"),
+            submitted_at_micros: current_utc_micros(),
+        })
+        .await
+        .map_err(|error| big_fish_error_response(&request_context, map_big_fish_client_error(error)))?;
+
+    Ok(json_success_body(
+        Some(&request_context),
+        BigFishSessionResponse {
+            session: map_big_fish_session_response(session),
+        },
+    ))
+}
+
+pub async fn stream_big_fish_message(
+    State(state): State<AppState>,
+    Path(session_id): Path<String>,
+    Extension(request_context): Extension<RequestContext>,
+    Extension(authenticated): Extension<AuthenticatedAccessToken>,
+    payload: Result<Json<SendBigFishMessageRequest>, JsonRejection>,
+) -> Result<Response, Response> {
+    let Json(payload) = payload.map_err(|error| {
+        big_fish_error_response(
+            &request_context,
+            AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
+                "provider": "big-fish",
+                "message": error.body_text(),
+            })),
+        )
+    })?;
+    ensure_non_empty(&request_context, &session_id, "sessionId")?;
+
+    let owner_user_id = authenticated.claims().user_id().to_string();
+    let session = state
+        .spacetime_client()
+        .submit_big_fish_message(BigFishMessageSubmitRecordInput {
+            session_id,
+            owner_user_id,
+            user_message_id: payload.client_message_id.trim().to_string(),
+            user_message_text: payload.text.trim().to_string(),
+            assistant_message_id: build_prefixed_uuid_id("big-fish-message-"),
+            submitted_at_micros: current_utc_micros(),
+        })
+        .await
+        .map_err(|error| big_fish_error_response(&request_context, map_big_fish_client_error(error)))?;
+
+    let session_response = map_big_fish_session_response(session);
+    let reply_text = session_response
+        .last_assistant_reply
+        .clone()
+        .unwrap_or_else(|| "锚点已更新。".to_string());
+    let mut sse_body = String::new();
+    append_sse_event(&request_context, &mut sse_body, "reply_delta", &json!({ "text": reply_text }))?;
+    append_sse_event(&request_context, &mut sse_body, "session", &json!({ "session": session_response }))?;
+    append_sse_event(&request_context, &mut sse_body, "done", &json!({ "ok": true }))?;
+    Ok(build_event_stream_response(sse_body))
+}
+
+pub async fn execute_big_fish_action(
+    State(state): State<AppState>,
+    Path(session_id): Path<String>,
+    Extension(request_context): Extension<RequestContext>,
+    Extension(authenticated): Extension<AuthenticatedAccessToken>,
+    payload: Result<Json<ExecuteBigFishActionRequest>, JsonRejection>,
+) -> Result<Json<Value>, Response> {
+    let Json(payload) = payload.map_err(|error| {
+        big_fish_error_response(
+            &request_context,
+            AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
+                "provider": "big-fish",
+                "message": error.body_text(),
+            })),
+        )
+    })?;
+    ensure_non_empty(&request_context, &session_id, "sessionId")?;
+
+    let owner_user_id = authenticated.claims().user_id().to_string();
+    let now = current_utc_micros();
+    let session = match payload.action.trim() {
+        "big_fish_compile_draft" => {
+            state
+                .spacetime_client()
+                .compile_big_fish_draft(session_id, owner_user_id, now)
+                .await
+        }
+        "big_fish_generate_level_main_image" => {
+            state
+                .spacetime_client()
+                .generate_big_fish_asset(BigFishAssetGenerateRecordInput {
+                    session_id,
+                    owner_user_id,
+                    asset_kind: "level_main_image".to_string(),
+                    level: payload.level,
+                    motion_key: None,
+                    generated_at_micros: now,
+                })
+                .await
+        }
+        "big_fish_generate_level_motion" => {
+            state
+                .spacetime_client()
+                .generate_big_fish_asset(BigFishAssetGenerateRecordInput {
+                    session_id,
+                    owner_user_id,
+                    asset_kind: "level_motion".to_string(),
+                    level: payload.level,
+                    motion_key: payload.motion_key,
+                    generated_at_micros: now,
+                })
+                .await
+        }
+        "big_fish_generate_stage_background" => {
+            state
+                .spacetime_client()
+                .generate_big_fish_asset(BigFishAssetGenerateRecordInput {
+                    session_id,
+                    owner_user_id,
+                    asset_kind: "stage_background".to_string(),
+                    level: None,
+                    motion_key: None,
+                    generated_at_micros: now,
+                })
+                .await
+        }
+        "big_fish_publish_game" => {
+            state
+                .spacetime_client()
+                .publish_big_fish_game(session_id, owner_user_id, now)
+                .await
+        }
+        other => {
+            return Err(big_fish_bad_request(
+                &request_context,
+                format!("action `{other}` is not supported").as_str(),
+            ));
+        }
+    }
+    .map_err(|error| big_fish_error_response(&request_context, map_big_fish_client_error(error)))?;
+
+    Ok(json_success_body(
+        Some(&request_context),
+        BigFishActionResponse {
+            session: map_big_fish_session_response(session),
+        },
+    ))
+}
+
+pub async fn start_big_fish_run(
+    State(state): State<AppState>,
+    Path(session_id): Path<String>,
+    Extension(request_context): Extension<RequestContext>,
+    Extension(authenticated): Extension<AuthenticatedAccessToken>,
+) -> Result<Json<Value>, Response> {
+    ensure_non_empty(&request_context, &session_id, "sessionId")?;
+
+    let run = state
+        .spacetime_client()
+        .start_big_fish_run(BigFishRunStartRecordInput {
+            run_id: build_prefixed_uuid_id("big-fish-run-"),
+            session_id,
+            owner_user_id: authenticated.claims().user_id().to_string(),
+            started_at_micros: current_utc_micros(),
+        })
+        .await
+        .map_err(|error| big_fish_error_response(&request_context, map_big_fish_client_error(error)))?;
+
+    Ok(json_success_body(
+        Some(&request_context),
+        BigFishRunResponse {
+            run: map_big_fish_runtime_response(run),
+        },
+    ))
+}
+
+pub async fn get_big_fish_run(
+    State(state): State<AppState>,
+    Path(run_id): Path<String>,
+    Extension(request_context): Extension<RequestContext>,
+    Extension(authenticated): Extension<AuthenticatedAccessToken>,
+) -> Result<Json<Value>, Response> {
+    ensure_non_empty(&request_context, &run_id, "runId")?;
+
+    let run = state
+        .spacetime_client()
+        .get_big_fish_run(run_id, authenticated.claims().user_id().to_string())
+        .await
+        .map_err(|error| big_fish_error_response(&request_context, map_big_fish_client_error(error)))?;
+
+    Ok(json_success_body(
+        Some(&request_context),
+        BigFishRunResponse {
+            run: map_big_fish_runtime_response(run),
+        },
+    ))
+}
+
+pub async fn submit_big_fish_input(
+    State(state): State<AppState>,
+    Path(run_id): Path<String>,
+    Extension(request_context): Extension<RequestContext>,
+    Extension(authenticated): Extension<AuthenticatedAccessToken>,
+    payload: Result<Json<SubmitBigFishInputRequest>, JsonRejection>,
+) -> Result<Json<Value>, Response> {
+    let Json(payload) = payload.map_err(|error| {
+        big_fish_error_response(
+            &request_context,
+            AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
+                "provider": "big-fish",
+                "message": error.body_text(),
+            })),
+        )
+    })?;
+    ensure_non_empty(&request_context, &run_id, "runId")?;
+
+    let run = state
+        .spacetime_client()
+        .submit_big_fish_input(BigFishRunInputSubmitRecordInput {
+            run_id,
+            owner_user_id: authenticated.claims().user_id().to_string(),
+            input_x: payload.x,
+            input_y: payload.y,
+            submitted_at_micros: current_utc_micros(),
+        })
+        .await
+        .map_err(|error| big_fish_error_response(&request_context, map_big_fish_client_error(error)))?;
+
+    Ok(json_success_body(
+        Some(&request_context),
+        BigFishRunResponse {
+            run: map_big_fish_runtime_response(run),
+        },
+    ))
+}
+
+fn map_big_fish_session_response(session: BigFishSessionRecord) -> BigFishSessionSnapshotResponse {
+    BigFishSessionSnapshotResponse {
+        session_id: session.session_id,
+        current_turn: session.current_turn,
+        progress_percent: session.progress_percent,
+        stage: session.stage,
+        anchor_pack: map_big_fish_anchor_pack_response(session.anchor_pack),
+        draft: session.draft.map(map_big_fish_draft_response),
+        asset_slots: session
+            .asset_slots
+            .into_iter()
+            .map(map_big_fish_asset_slot_response)
+            .collect(),
+        asset_coverage: map_big_fish_asset_coverage_response(session.asset_coverage),
+        messages: session
+            .messages
+            .into_iter()
+            .map(map_big_fish_agent_message_response)
+            .collect(),
+        last_assistant_reply: session.last_assistant_reply,
+        publish_ready: session.publish_ready,
+        updated_at: session.updated_at,
+    }
+}
+
+fn map_big_fish_anchor_pack_response(anchor_pack: BigFishAnchorPackRecord) -> BigFishAnchorPackResponse {
+    BigFishAnchorPackResponse {
+        gameplay_promise: map_big_fish_anchor_item_response(anchor_pack.gameplay_promise),
+        ecology_visual_theme: map_big_fish_anchor_item_response(anchor_pack.ecology_visual_theme),
+        growth_ladder: map_big_fish_anchor_item_response(anchor_pack.growth_ladder),
+        risk_tempo: map_big_fish_anchor_item_response(anchor_pack.risk_tempo),
+    }
+}
+
+fn map_big_fish_anchor_item_response(anchor: BigFishAnchorItemRecord) -> BigFishAnchorItemResponse {
+    BigFishAnchorItemResponse {
+        key: anchor.key,
+        label: anchor.label,
+        value: anchor.value,
+        status: anchor.status,
+    }
+}
+
+fn map_big_fish_draft_response(draft: BigFishGameDraftRecord) -> BigFishGameDraftResponse {
+    BigFishGameDraftResponse {
+        title: draft.title,
+        subtitle: draft.subtitle,
+        core_fun: draft.core_fun,
+        ecology_theme: draft.ecology_theme,
+        levels: draft
+            .levels
+            .into_iter()
+            .map(map_big_fish_level_response)
+            .collect(),
+        background: map_big_fish_background_response(draft.background),
+        runtime_params: map_big_fish_runtime_params_response(draft.runtime_params),
+    }
+}
+
+fn map_big_fish_level_response(level: BigFishLevelBlueprintRecord) -> BigFishLevelBlueprintResponse {
+    BigFishLevelBlueprintResponse {
+        level: level.level,
+        name: level.name,
+        one_line_fantasy: level.one_line_fantasy,
+        silhouette_direction: level.silhouette_direction,
+        size_ratio: level.size_ratio,
+        visual_prompt_seed: level.visual_prompt_seed,
+        motion_prompt_seed: level.motion_prompt_seed,
+        merge_source_level: level.merge_source_level,
+        prey_window: level.prey_window,
+        threat_window: level.threat_window,
+        is_final_level: level.is_final_level,
+    }
+}
+
+fn map_big_fish_background_response(
+    background: BigFishBackgroundBlueprintRecord,
+) -> BigFishBackgroundBlueprintResponse {
+    BigFishBackgroundBlueprintResponse {
+        theme: background.theme,
+        color_mood: background.color_mood,
+        foreground_hints: background.foreground_hints,
+        midground_composition: background.midground_composition,
+        background_depth: background.background_depth,
+        safe_play_area_hint: background.safe_play_area_hint,
+        spawn_edge_hint: background.spawn_edge_hint,
+        background_prompt_seed: background.background_prompt_seed,
+    }
+}
+
+fn map_big_fish_runtime_params_response(
+    params: BigFishRuntimeParamsRecord,
+) -> BigFishRuntimeParamsResponse {
+    BigFishRuntimeParamsResponse {
+        level_count: params.level_count,
+        merge_count_per_upgrade: params.merge_count_per_upgrade,
+        spawn_target_count: params.spawn_target_count,
+        leader_move_speed: params.leader_move_speed,
+        follower_catch_up_speed: params.follower_catch_up_speed,
+        offscreen_cull_seconds: params.offscreen_cull_seconds,
+        prey_spawn_delta_levels: params.prey_spawn_delta_levels,
+        threat_spawn_delta_levels: params.threat_spawn_delta_levels,
+        win_level: params.win_level,
+    }
+}
+
+fn map_big_fish_asset_slot_response(slot: BigFishAssetSlotRecord) -> BigFishAssetSlotResponse {
+    BigFishAssetSlotResponse {
+        slot_id: slot.slot_id,
+        asset_kind: slot.asset_kind,
+        level: slot.level,
+        motion_key: slot.motion_key,
+        status: slot.status,
+        asset_url: slot.asset_url,
+        prompt_snapshot: slot.prompt_snapshot,
+        updated_at: slot.updated_at,
+    }
+}
+
+fn map_big_fish_asset_coverage_response(
+    coverage: BigFishAssetCoverageRecord,
+) -> BigFishAssetCoverageResponse {
+    BigFishAssetCoverageResponse {
+        level_main_image_ready_count: coverage.level_main_image_ready_count,
+        level_motion_ready_count: coverage.level_motion_ready_count,
+        background_ready: coverage.background_ready,
+        required_level_count: coverage.required_level_count,
+        publish_ready: coverage.publish_ready,
+        blockers: coverage.blockers,
+    }
+}
+
+fn map_big_fish_agent_message_response(
+    message: BigFishAgentMessageRecord,
+) -> BigFishAgentMessageResponse {
+    BigFishAgentMessageResponse {
+        id: message.message_id,
+        role: message.role,
+        kind: message.kind,
+        text: message.text,
+        created_at: message.created_at,
+    }
+}
+
+fn map_big_fish_runtime_response(run: BigFishRuntimeRecord) -> BigFishRuntimeSnapshotResponse {
+    BigFishRuntimeSnapshotResponse {
+        run_id: run.run_id,
+        session_id: run.session_id,
+        status: run.status,
+        tick: run.tick,
+        player_level: run.player_level,
+        win_level: run.win_level,
+        leader_entity_id: run.leader_entity_id,
+        owned_entities: run
+            .owned_entities
+            .into_iter()
+            .map(map_big_fish_entity_response)
+            .collect(),
+        wild_entities: run
+            .wild_entities
+            .into_iter()
+            .map(map_big_fish_entity_response)
+            .collect(),
+        camera_center: map_big_fish_vector_response(run.camera_center),
+        last_input: map_big_fish_vector_response(run.last_input),
+        event_log: run.event_log,
+        updated_at: run.updated_at,
+    }
+}
+
+fn map_big_fish_entity_response(entity: BigFishRuntimeEntityRecord) -> BigFishRuntimeEntityResponse {
+    BigFishRuntimeEntityResponse {
+        entity_id: entity.entity_id,
+        level: entity.level,
+        position: map_big_fish_vector_response(entity.position),
+        radius: entity.radius,
+        offscreen_seconds: entity.offscreen_seconds,
+    }
+}
+
+fn map_big_fish_vector_response(vector: BigFishVector2Record) -> BigFishVector2Response {
+    BigFishVector2Response {
+        x: vector.x,
+        y: vector.y,
+    }
+}
+
+fn build_big_fish_welcome_text(seed_text: &str) -> String {
+    if seed_text.trim().is_empty() {
+        return "我会先帮你确定大鱼吃小鱼的核心锚点。可以从主题生态、成长阶梯或风险节奏开始。".to_string();
+    }
+    "我已经收到你的玩法起点，会先把它整理成锚点并准备结果页草稿。".to_string()
+}
+
+fn ensure_non_empty(
+    request_context: &RequestContext,
+    value: &str,
+    field_name: &str,
+) -> Result<(), Response> {
+    if value.trim().is_empty() {
+        return Err(big_fish_bad_request(
+            request_context,
+            format!("{field_name} is required").as_str(),
+        ));
+    }
+    Ok(())
+}
+
+fn big_fish_bad_request(request_context: &RequestContext, message: &str) -> Response {
+    big_fish_error_response(
+        request_context,
+        AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
+            "provider": "big-fish",
+            "message": message,
+        })),
+    )
+}
+
+fn append_sse_event(
+    request_context: &RequestContext,
+    body: &mut String,
+    event: &str,
+    payload: &Value,
+) -> Result<(), Response> {
+    let payload_text = serde_json::to_string(payload).map_err(|error| {
+        big_fish_error_response(
+            request_context,
+            AppError::from_status(StatusCode::INTERNAL_SERVER_ERROR).with_details(json!({
+                "provider": "big-fish",
+                "message": format!("SSE payload 序列化失败：{error}"),
+            })),
+        )
+    })?;
+    body.push_str("event: ");
+    body.push_str(event);
+    body.push('\n');
+    body.push_str("data: ");
+    body.push_str(&payload_text);
+    body.push_str("\n\n");
+    Ok(())
+}
+
+fn build_event_stream_response(body: String) -> Response {
+    (
+        [
+            (header::CONTENT_TYPE, "text/event-stream; charset=utf-8"),
+            (header::CACHE_CONTROL, "no-cache"),
+            (HeaderName::from_static("x-accel-buffering"), "no"),
+        ],
+        body,
+    )
+        .into_response()
+}
+
+fn map_big_fish_client_error(error: SpacetimeClientError) -> AppError {
+    let status = match &error {
+        SpacetimeClientError::Procedure(message)
+            if message.contains("big_fish_creation_session 不存在")
+                || message.contains("big_fish_runtime_run 不存在") =>
+        {
+            StatusCode::NOT_FOUND
+        }
+        SpacetimeClientError::Procedure(message)
+            if message.contains("不能为空")
+                || message.contains("尚未编译")
+                || message.contains("不允许")
+                || message.contains("非法")
+                || message.contains("缺少") =>
+        {
+            StatusCode::BAD_REQUEST
+        }
+        SpacetimeClientError::Runtime(_) => StatusCode::BAD_REQUEST,
+        _ => StatusCode::BAD_GATEWAY,
+    };
+
+    AppError::from_status(status).with_details(json!({
+        "provider": "spacetimedb",
+        "message": error.to_string(),
+    }))
+}
+
+fn big_fish_error_response(request_context: &RequestContext, error: AppError) -> Response {
+    error.into_response_with_context(Some(request_context))
+}
+
+fn current_utc_micros() -> i64 {
+    use std::time::{SystemTime, UNIX_EPOCH};
+
+    let duration = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .expect("system clock should be after unix epoch");
+    i64::try_from(duration.as_micros()).expect("current unix micros should fit in i64")
+}