1

2026-04-28 19:36:39 +08:00
parent a9febe7678
commit f0471a4f8d
206 changed files with 18456 additions and 10133 deletions
--- a/server-rs/crates/api-server/src/runtime_chat_plain.rs
+++ b/server-rs/crates/api-server/src/runtime_chat_plain.rs
@@ -0,0 +1,615 @@
+use axum::{
+    Json,
+    extract::{Extension, State},
+    http::StatusCode,
+    response::{
+        IntoResponse, Response,
+        sse::{Event, Sse},
+    },
+};
+use platform_llm::{LlmMessage, LlmTextRequest};
+use serde::Deserialize;
+use serde_json::{Value, json};
+use std::convert::Infallible;
+
+use crate::{
+    api_response::json_success_body, auth::AuthenticatedAccessToken, http_error::AppError,
+    prompt::runtime_chat::*, request_context::RequestContext, state::AppState,
+};
+use module_runtime_story_compat::{
+    RuntimeStoryPromptContextExtras, build_runtime_story_prompt_context, current_world_type,
+    normalize_required_string, read_array_field, read_field, read_runtime_session_id,
+};
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RuntimeCharacterChatRequest {
+    #[serde(default)]
+    session_id: Option<String>,
+    #[serde(default)]
+    world_type: String,
+    #[serde(default)]
+    player_character: Value,
+    #[serde(default)]
+    target_character: Value,
+    #[serde(default)]
+    story_history: Vec<Value>,
+    #[serde(default)]
+    context: Value,
+    #[serde(default)]
+    conversation_history: Vec<Value>,
+    #[serde(default)]
+    conversation_summary: String,
+    #[serde(default)]
+    previous_summary: String,
+    #[serde(default)]
+    player_message: String,
+    #[serde(default)]
+    target_status: Value,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RuntimeNpcDialogueRequest {
+    #[serde(default)]
+    session_id: Option<String>,
+    #[serde(default)]
+    world_type: String,
+    #[serde(default)]
+    character: Value,
+    #[serde(default)]
+    encounter: Value,
+    #[serde(default)]
+    monsters: Vec<Value>,
+    #[serde(default)]
+    history: Vec<Value>,
+    #[serde(default)]
+    context: Value,
+    #[serde(default)]
+    topic: String,
+    #[serde(default)]
+    result_summary: String,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RuntimeNpcRecruitDialogueRequest {
+    #[serde(default)]
+    session_id: Option<String>,
+    #[serde(default)]
+    world_type: String,
+    #[serde(default)]
+    character: Value,
+    #[serde(default)]
+    encounter: Value,
+    #[serde(default)]
+    monsters: Vec<Value>,
+    #[serde(default)]
+    history: Vec<Value>,
+    #[serde(default)]
+    context: Value,
+    #[serde(default)]
+    invitation_text: String,
+    #[serde(default)]
+    recruit_summary: String,
+}
+
+pub async fn generate_runtime_character_chat_suggestions(
+    State(state): State<AppState>,
+    Extension(request_context): Extension<RequestContext>,
+    Extension(authenticated): Extension<AuthenticatedAccessToken>,
+    Json(mut payload): Json<RuntimeCharacterChatRequest>,
+) -> Result<Json<Value>, Response> {
+    hydrate_character_chat_request_from_session(
+        &state,
+        &request_context,
+        authenticated.claims().user_id().to_string(),
+        &mut payload,
+    )
+    .await?;
+
+    let text = request_runtime_plain_text(
+        &state,
+        build_character_chat_suggestions_system_prompt(),
+        build_character_chat_suggestions_user_prompt(CharacterChatPromptParams {
+            world_type: payload.world_type.as_str(),
+            player_character: &payload.player_character,
+            target_character: &payload.target_character,
+            story_history: &payload.story_history,
+            context: &payload.context,
+            conversation_history: &payload.conversation_history,
+            conversation_summary: payload.conversation_summary.as_str(),
+            previous_summary: payload.previous_summary.as_str(),
+            player_message: payload.player_message.as_str(),
+            target_status: &payload.target_status,
+        }),
+        Some(build_character_chat_suggestions_fallback(
+            &payload.target_character,
+        )),
+    )
+    .await;
+
+    Ok(json_success_body(
+        Some(&request_context),
+        json!({ "text": text }),
+    ))
+}
+
+pub async fn generate_runtime_character_chat_summary(
+    State(state): State<AppState>,
+    Extension(request_context): Extension<RequestContext>,
+    Extension(authenticated): Extension<AuthenticatedAccessToken>,
+    Json(mut payload): Json<RuntimeCharacterChatRequest>,
+) -> Result<Json<Value>, Response> {
+    hydrate_character_chat_request_from_session(
+        &state,
+        &request_context,
+        authenticated.claims().user_id().to_string(),
+        &mut payload,
+    )
+    .await?;
+
+    let text = request_runtime_plain_text(
+        &state,
+        build_character_chat_summary_system_prompt(),
+        build_character_chat_summary_user_prompt(CharacterChatPromptParams {
+            world_type: payload.world_type.as_str(),
+            player_character: &payload.player_character,
+            target_character: &payload.target_character,
+            story_history: &payload.story_history,
+            context: &payload.context,
+            conversation_history: &payload.conversation_history,
+            conversation_summary: payload.conversation_summary.as_str(),
+            previous_summary: payload.previous_summary.as_str(),
+            player_message: payload.player_message.as_str(),
+            target_status: &payload.target_status,
+        }),
+        Some(build_character_chat_summary_fallback(
+            &payload.target_character,
+            &payload.conversation_history,
+            payload.previous_summary.as_str(),
+        )),
+    )
+    .await;
+
+    Ok(json_success_body(
+        Some(&request_context),
+        json!({ "text": text }),
+    ))
+}
+
+pub async fn stream_runtime_character_chat_reply(
+    State(state): State<AppState>,
+    Extension(request_context): Extension<RequestContext>,
+    Extension(authenticated): Extension<AuthenticatedAccessToken>,
+    Json(mut payload): Json<RuntimeCharacterChatRequest>,
+) -> Result<Response, Response> {
+    hydrate_character_chat_request_from_session(
+        &state,
+        &request_context,
+        authenticated.claims().user_id().to_string(),
+        &mut payload,
+    )
+    .await?;
+
+    let player_message = payload.player_message.trim().to_string();
+    if player_message.is_empty() {
+        return Err(runtime_plain_chat_error_response(
+            &request_context,
+            AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
+                "provider": "runtime-chat",
+                "message": "playerMessage 不能为空",
+            })),
+        ));
+    }
+
+    let stream = stream_plain_text_response(
+        state.llm_client().cloned(),
+        state.config.rpg_llm_web_search_enabled,
+        build_character_chat_reply_system_prompt(),
+        build_character_chat_reply_user_prompt(CharacterChatPromptParams {
+            world_type: payload.world_type.as_str(),
+            player_character: &payload.player_character,
+            target_character: &payload.target_character,
+            story_history: &payload.story_history,
+            context: &payload.context,
+            conversation_history: &payload.conversation_history,
+            conversation_summary: payload.conversation_summary.as_str(),
+            previous_summary: payload.previous_summary.as_str(),
+            player_message: payload.player_message.as_str(),
+            target_status: &payload.target_status,
+        }),
+        build_character_chat_reply_fallback(
+            &payload.target_character,
+            payload.player_message.as_str(),
+            payload.conversation_summary.as_str(),
+        ),
+    );
+
+    Ok(Sse::new(stream).into_response())
+}
+
+pub async fn stream_runtime_npc_chat_dialogue(
+    State(state): State<AppState>,
+    Extension(request_context): Extension<RequestContext>,
+    Extension(authenticated): Extension<AuthenticatedAccessToken>,
+    Json(mut payload): Json<RuntimeNpcDialogueRequest>,
+) -> Result<Response, Response> {
+    hydrate_npc_dialogue_request_from_session(
+        &state,
+        &request_context,
+        authenticated.claims().user_id().to_string(),
+        &mut payload,
+    )
+    .await?;
+
+    let topic = payload.topic.trim().to_string();
+    if topic.is_empty() {
+        return Err(runtime_plain_chat_error_response(
+            &request_context,
+            AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
+                "provider": "runtime-chat",
+                "message": "topic 不能为空",
+            })),
+        ));
+    }
+
+    let stream = stream_plain_text_response(
+        state.llm_client().cloned(),
+        state.config.rpg_llm_web_search_enabled,
+        runtime_npc_dialogue_system_prompt(),
+        {
+            let npc_name = read_name_field(&payload.encounter, "npcName")
+                .or_else(|| read_name_field(&payload.encounter, "name"))
+                .unwrap_or_else(|| "对方".to_string());
+            build_runtime_npc_dialogue_user_prompt(
+                npc_name.as_str(),
+                RuntimeNpcDialoguePromptParams {
+                    world_type: payload.world_type.as_str(),
+                    character: &payload.character,
+                    encounter: &payload.encounter,
+                    monsters: payload.monsters.clone(),
+                    history: payload.history.clone(),
+                    context: payload.context.clone(),
+                    topic: payload.topic.as_str(),
+                    result_summary: payload.result_summary.as_str(),
+                    requested_option: Value::Null,
+                    available_options: Vec::new(),
+                },
+            )
+        },
+        build_npc_chat_dialogue_fallback(&payload.encounter, payload.topic.as_str()),
+    );
+
+    Ok(Sse::new(stream).into_response())
+}
+
+pub async fn stream_runtime_npc_recruit_dialogue(
+    State(state): State<AppState>,
+    Extension(request_context): Extension<RequestContext>,
+    Extension(authenticated): Extension<AuthenticatedAccessToken>,
+    Json(mut payload): Json<RuntimeNpcRecruitDialogueRequest>,
+) -> Result<Response, Response> {
+    hydrate_npc_recruit_request_from_session(
+        &state,
+        &request_context,
+        authenticated.claims().user_id().to_string(),
+        &mut payload,
+    )
+    .await?;
+
+    let invitation_text = payload.invitation_text.trim().to_string();
+    if invitation_text.is_empty() {
+        return Err(runtime_plain_chat_error_response(
+            &request_context,
+            AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
+                "provider": "runtime-chat",
+                "message": "invitationText 不能为空",
+            })),
+        ));
+    }
+
+    let npc_name = read_name_field(&payload.encounter, "npcName")
+        .or_else(|| read_name_field(&payload.encounter, "name"))
+        .unwrap_or_else(|| "对方".to_string());
+    let stream = stream_plain_text_response(
+        state.llm_client().cloned(),
+        state.config.rpg_llm_web_search_enabled,
+        build_npc_recruit_dialogue_system_prompt(),
+        build_npc_recruit_dialogue_user_prompt(
+            npc_name.as_str(),
+            NpcRecruitDialoguePromptParams {
+                world_type: payload.world_type.as_str(),
+                character: &payload.character,
+                encounter: &payload.encounter,
+                monsters: &payload.monsters,
+                history: &payload.history,
+                context: &payload.context,
+                invitation_text: payload.invitation_text.as_str(),
+                recruit_summary: payload.recruit_summary.as_str(),
+            },
+        ),
+        build_npc_recruit_dialogue_fallback(&payload.encounter),
+    );
+
+    Ok(Sse::new(stream).into_response())
+}
+
+async fn hydrate_character_chat_request_from_session(
+    state: &AppState,
+    request_context: &RequestContext,
+    user_id: String,
+    payload: &mut RuntimeCharacterChatRequest,
+) -> Result<(), Response> {
+    let Some(game_state) = resolve_runtime_chat_game_state(
+        state,
+        request_context,
+        user_id,
+        payload.session_id.as_deref(),
+    )
+    .await?
+    else {
+        return Ok(());
+    };
+
+    payload.world_type = current_world_type(&game_state).unwrap_or_default();
+    payload.player_character = read_field(&game_state, "playerCharacter")
+        .cloned()
+        .unwrap_or(Value::Null);
+    payload.story_history = read_array_field(&game_state, "storyHistory")
+        .into_iter()
+        .rev()
+        .take(12)
+        .collect::<Vec<_>>()
+        .into_iter()
+        .rev()
+        .cloned()
+        .collect();
+    payload.context =
+        build_runtime_story_prompt_context(&game_state, RuntimeStoryPromptContextExtras::default());
+
+    Ok(())
+}
+
+async fn hydrate_npc_dialogue_request_from_session(
+    state: &AppState,
+    request_context: &RequestContext,
+    user_id: String,
+    payload: &mut RuntimeNpcDialogueRequest,
+) -> Result<(), Response> {
+    let Some(game_state) = resolve_runtime_chat_game_state(
+        state,
+        request_context,
+        user_id,
+        payload.session_id.as_deref(),
+    )
+    .await?
+    else {
+        return Ok(());
+    };
+
+    payload.world_type = current_world_type(&game_state).unwrap_or_default();
+    payload.character = read_field(&game_state, "playerCharacter")
+        .cloned()
+        .unwrap_or(Value::Null);
+    payload.encounter = read_field(&game_state, "currentEncounter")
+        .cloned()
+        .unwrap_or_else(|| payload.encounter.clone());
+    payload.monsters = read_array_field(&game_state, "sceneHostileNpcs")
+        .into_iter()
+        .cloned()
+        .collect();
+    payload.history = read_array_field(&game_state, "storyHistory")
+        .into_iter()
+        .rev()
+        .take(12)
+        .collect::<Vec<_>>()
+        .into_iter()
+        .rev()
+        .cloned()
+        .collect();
+    payload.context = build_runtime_story_prompt_context(
+        &game_state,
+        RuntimeStoryPromptContextExtras {
+            last_function_id: Some("npc_chat".to_string()),
+            ..RuntimeStoryPromptContextExtras::default()
+        },
+    );
+
+    Ok(())
+}
+
+async fn hydrate_npc_recruit_request_from_session(
+    state: &AppState,
+    request_context: &RequestContext,
+    user_id: String,
+    payload: &mut RuntimeNpcRecruitDialogueRequest,
+) -> Result<(), Response> {
+    let Some(game_state) = resolve_runtime_chat_game_state(
+        state,
+        request_context,
+        user_id,
+        payload.session_id.as_deref(),
+    )
+    .await?
+    else {
+        return Ok(());
+    };
+
+    payload.world_type = current_world_type(&game_state).unwrap_or_default();
+    payload.character = read_field(&game_state, "playerCharacter")
+        .cloned()
+        .unwrap_or(Value::Null);
+    payload.encounter = read_field(&game_state, "currentEncounter")
+        .cloned()
+        .unwrap_or_else(|| payload.encounter.clone());
+    payload.monsters = read_array_field(&game_state, "sceneHostileNpcs")
+        .into_iter()
+        .cloned()
+        .collect();
+    payload.history = read_array_field(&game_state, "storyHistory")
+        .into_iter()
+        .rev()
+        .take(12)
+        .collect::<Vec<_>>()
+        .into_iter()
+        .rev()
+        .cloned()
+        .collect();
+    payload.context = build_runtime_story_prompt_context(
+        &game_state,
+        RuntimeStoryPromptContextExtras {
+            last_function_id: Some("npc_recruit".to_string()),
+            ..RuntimeStoryPromptContextExtras::default()
+        },
+    );
+
+    Ok(())
+}
+
+async fn resolve_runtime_chat_game_state(
+    state: &AppState,
+    request_context: &RequestContext,
+    user_id: String,
+    session_id: Option<&str>,
+) -> Result<Option<Value>, Response> {
+    let Some(session_id) = session_id.and_then(normalize_required_string) else {
+        // 中文注释：未携带 sessionId 的旧调用仅保留兼容，后续正式运行态应全部走后端快照。
+        return Ok(None);
+    };
+    let record = state
+        .get_runtime_snapshot_record(user_id)
+        .await
+        .map_err(|error| {
+            runtime_plain_chat_error_response(
+                request_context,
+                AppError::from_status(StatusCode::BAD_GATEWAY).with_details(json!({
+                    "provider": "spacetimedb",
+                    "message": error.to_string(),
+                })),
+            )
+        })?
+        .ok_or_else(|| {
+            runtime_plain_chat_error_response(
+                request_context,
+                AppError::from_status(StatusCode::CONFLICT).with_details(json!({
+                    "provider": "runtime-chat",
+                    "message": "运行时快照不存在，请先初始化并保存一次游戏",
+                })),
+            )
+        })?;
+    let game_state = record.game_state;
+    let snapshot_session_id =
+        read_runtime_session_id(&game_state).unwrap_or_else(|| session_id.clone());
+    if snapshot_session_id != session_id {
+        return Err(runtime_plain_chat_error_response(
+            request_context,
+            AppError::from_status(StatusCode::CONFLICT).with_details(json!({
+                "provider": "runtime-chat",
+                "message": "请求的运行时会话与服务端快照不一致，请重新进入游戏",
+                "sessionId": session_id,
+                "snapshotSessionId": snapshot_session_id,
+            })),
+        ));
+    }
+
+    Ok(Some(game_state))
+}
+
+async fn request_runtime_plain_text(
+    state: &AppState,
+    system_prompt: &'static str,
+    user_prompt: String,
+    fallback_text: Option<String>,
+) -> String {
+    let Some(llm_client) = state.llm_client() else {
+        return fallback_text.unwrap_or_default();
+    };
+
+    let mut request = LlmTextRequest::new(vec![
+        LlmMessage::system(system_prompt),
+        LlmMessage::user(user_prompt),
+    ]);
+    request.max_tokens = Some(400);
+    request.enable_web_search = state.config.rpg_llm_web_search_enabled;
+
+    llm_client
+        .request_text(request)
+        .await
+        .ok()
+        .map(|response| response.content.trim().to_string())
+        .filter(|text| !text.is_empty())
+        .or(fallback_text)
+        .unwrap_or_default()
+}
+
+fn stream_plain_text_response<'a>(
+    llm_client: Option<platform_llm::LlmClient>,
+    enable_web_search: bool,
+    system_prompt: &'static str,
+    user_prompt: String,
+    fallback_text: String,
+) -> impl tokio_stream::Stream<Item = Result<Event, Infallible>> {
+    async_stream::stream! {
+        let Some(llm_client) = llm_client else {
+            yield Ok::<Event, Infallible>(Event::default().data(runtime_plain_text_sse_payload(fallback_text.as_str())));
+            yield Ok::<Event, Infallible>(Event::default().data("[DONE]"));
+            return;
+        };
+
+        let mut request = LlmTextRequest::new(vec![
+            LlmMessage::system(system_prompt),
+            LlmMessage::user(user_prompt),
+        ]);
+        request.max_tokens = Some(700);
+        request.enable_web_search = enable_web_search;
+
+        let response = llm_client
+            .stream_text(request, |_| {})
+            .await;
+
+        match response {
+            Ok(response) => {
+                let final_text = response.content.trim();
+                let output = if final_text.is_empty() {
+                    fallback_text.as_str()
+                } else {
+                    final_text
+                };
+                yield Ok::<Event, Infallible>(Event::default().data(runtime_plain_text_sse_payload(output)));
+            }
+            Err(_) => {
+                yield Ok::<Event, Infallible>(Event::default().data(runtime_plain_text_sse_payload(fallback_text.as_str())));
+            }
+        }
+
+        yield Ok::<Event, Infallible>(Event::default().data("[DONE]"));
+    }
+}
+
+fn runtime_plain_text_sse_payload(text: &str) -> String {
+    json!({
+        "choices": [{
+            "delta": {
+                "content": text,
+            }
+        }]
+    })
+    .to_string()
+}
+
+fn runtime_plain_chat_error_response(
+    request_context: &RequestContext,
+    error: AppError,
+) -> Response {
+    error.into_response_with_context(Some(request_context))
+}
+
+fn read_name_field(value: &Value, field: &str) -> Option<String> {
+    value
+        .get(field)
+        .and_then(Value::as_str)
+        .map(str::trim)
+        .filter(|text| !text.is_empty())
+        .map(ToOwned::to_owned)
+}