1

server-rs/crates/spacetime-client/src/visual_novel.rs

@@ -0,0 +1,466 @@
+use super::*;
+use crate::mapper::{
+    VisualNovelAgentMessageFinalizeRecordInput, VisualNovelAgentMessageSubmitRecordInput,
+    VisualNovelAgentSessionCreateRecordInput, VisualNovelAgentSessionRecord,
+    VisualNovelHistoryEntryRecord, VisualNovelHistoryEntryRecordInput, VisualNovelRunRecord,
+    VisualNovelRunSnapshotRecordInput, VisualNovelRunStartRecordInput,
+    VisualNovelRuntimeEventRecord, VisualNovelWorkCompileRecordInput, VisualNovelWorkProfileRecord,
+    VisualNovelWorkUpdateRecordInput, map_visual_novel_agent_session_procedure_result,
+    map_visual_novel_history_procedure_result, map_visual_novel_run_procedure_result,
+    map_visual_novel_runtime_event_procedure_result, map_visual_novel_work_procedure_result,
+    map_visual_novel_works_procedure_result,
+};
+
+impl SpacetimeClient {
+    pub async fn create_visual_novel_agent_session(
+        &self,
+        input: VisualNovelAgentSessionCreateRecordInput,
+    ) -> Result<VisualNovelAgentSessionRecord, SpacetimeClientError> {
+        let procedure_input = VisualNovelAgentSessionCreateInput {
+            session_id: input.session_id,
+            owner_user_id: input.owner_user_id,
+            source_mode: input.source_mode,
+            seed_text: input.seed_text,
+            source_asset_ids_json: input.source_asset_ids_json,
+            welcome_message_id: input.welcome_message_id,
+            welcome_message_text: input.welcome_message_text,
+            draft_json: input.draft_json,
+            created_at_micros: input.created_at_micros,
+        };
+
+        self.call_after_connect(move |connection, sender| {
+            connection.procedures().create_visual_novel_agent_session_then(
+                procedure_input,
+                move |_, result| {
+                    let mapped = result
+                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
+                        .and_then(map_visual_novel_agent_session_procedure_result);
+                    send_once(&sender, mapped);
+                },
+            );
+        })
+        .await
+    }
+
+    pub async fn get_visual_novel_agent_session(
+        &self,
+        session_id: String,
+        owner_user_id: String,
+    ) -> Result<VisualNovelAgentSessionRecord, SpacetimeClientError> {
+        let procedure_input = VisualNovelAgentSessionGetInput {
+            session_id,
+            owner_user_id,
+        };
+
+        self.call_after_connect(move |connection, sender| {
+            connection.procedures().get_visual_novel_agent_session_then(
+                procedure_input,
+                move |_, result| {
+                    let mapped = result
+                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
+                        .and_then(map_visual_novel_agent_session_procedure_result);
+                    send_once(&sender, mapped);
+                },
+            );
+        })
+        .await
+    }
+
+    pub async fn submit_visual_novel_agent_message(
+        &self,
+        input: VisualNovelAgentMessageSubmitRecordInput,
+    ) -> Result<VisualNovelAgentSessionRecord, SpacetimeClientError> {
+        let procedure_input = VisualNovelAgentMessageSubmitInput {
+            session_id: input.session_id,
+            owner_user_id: input.owner_user_id,
+            user_message_id: input.user_message_id,
+            user_message_text: input.user_message_text,
+            submitted_at_micros: input.submitted_at_micros,
+        };
+
+        self.call_after_connect(move |connection, sender| {
+            connection.procedures().submit_visual_novel_agent_message_then(
+                procedure_input,
+                move |_, result| {
+                    let mapped = result
+                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
+                        .and_then(map_visual_novel_agent_session_procedure_result);
+                    send_once(&sender, mapped);
+                },
+            );
+        })
+        .await
+    }
+
+    pub async fn finalize_visual_novel_agent_message(
+        &self,
+        input: VisualNovelAgentMessageFinalizeRecordInput,
+    ) -> Result<VisualNovelAgentSessionRecord, SpacetimeClientError> {
+        let procedure_input = VisualNovelAgentMessageFinalizeInput {
+            session_id: input.session_id,
+            owner_user_id: input.owner_user_id,
+            assistant_message_id: input.assistant_message_id,
+            assistant_reply_text: input.assistant_reply_text,
+            draft_json: input.draft_json,
+            pending_action_json: input.pending_action_json,
+            status: input.status,
+            progress_percent: input.progress_percent,
+            updated_at_micros: input.updated_at_micros,
+            error_message: input.error_message,
+        };
+
+        self.call_after_connect(move |connection, sender| {
+            connection
+                .procedures()
+                .finalize_visual_novel_agent_message_turn_then(procedure_input, move |_, result| {
+                    let mapped = result
+                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
+                        .and_then(map_visual_novel_agent_session_procedure_result);
+                    send_once(&sender, mapped);
+                });
+        })
+        .await
+    }
+
+    pub async fn compile_visual_novel_work_profile(
+        &self,
+        input: VisualNovelWorkCompileRecordInput,
+    ) -> Result<VisualNovelAgentSessionRecord, SpacetimeClientError> {
+        let procedure_input = VisualNovelWorkCompileInput {
+            session_id: input.session_id,
+            owner_user_id: input.owner_user_id,
+            profile_id: input.profile_id,
+            work_id: input.work_id,
+            author_display_name: input.author_display_name,
+            work_title: input.work_title,
+            work_description: input.work_description,
+            tags_json: input.tags_json,
+            cover_image_src: input.cover_image_src,
+            compiled_at_micros: input.compiled_at_micros,
+        };
+
+        self.call_after_connect(move |connection, sender| {
+            connection.procedures().compile_visual_novel_work_profile_then(
+                procedure_input,
+                move |_, result| {
+                    let mapped = result
+                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
+                        .and_then(map_visual_novel_agent_session_procedure_result);
+                    send_once(&sender, mapped);
+                },
+            );
+        })
+        .await
+    }
+
+    pub async fn update_visual_novel_work(
+        &self,
+        input: VisualNovelWorkUpdateRecordInput,
+    ) -> Result<VisualNovelWorkProfileRecord, SpacetimeClientError> {
+        let procedure_input = VisualNovelWorkUpdateInput {
+            profile_id: input.profile_id,
+            owner_user_id: input.owner_user_id,
+            work_title: input.work_title,
+            work_description: input.work_description,
+            tags_json: input.tags_json,
+            cover_image_src: input.cover_image_src,
+            source_asset_ids_json: input.source_asset_ids_json,
+            draft_json: input.draft_json,
+            publish_ready: input.publish_ready,
+            updated_at_micros: input.updated_at_micros,
+        };
+
+        self.call_after_connect(move |connection, sender| {
+            connection.procedures().update_visual_novel_work_then(
+                procedure_input,
+                move |_, result| {
+                    let mapped = result
+                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
+                        .and_then(map_visual_novel_work_procedure_result);
+                    send_once(&sender, mapped);
+                },
+            );
+        })
+        .await
+    }
+
+    pub async fn publish_visual_novel_work(
+        &self,
+        profile_id: String,
+        owner_user_id: String,
+        published_at_micros: i64,
+    ) -> Result<VisualNovelWorkProfileRecord, SpacetimeClientError> {
+        let procedure_input = VisualNovelWorkPublishInput {
+            profile_id,
+            owner_user_id,
+            published_at_micros,
+        };
+
+        self.call_after_connect(move |connection, sender| {
+            connection.procedures().publish_visual_novel_work_then(
+                procedure_input,
+                move |_, result| {
+                    let mapped = result
+                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
+                        .and_then(map_visual_novel_work_procedure_result);
+                    send_once(&sender, mapped);
+                },
+            );
+        })
+        .await
+    }
+
+    pub async fn list_visual_novel_works(
+        &self,
+        owner_user_id: String,
+    ) -> Result<Vec<VisualNovelWorkProfileRecord>, SpacetimeClientError> {
+        self.list_visual_novel_works_with_input(VisualNovelWorksListInput {
+            owner_user_id,
+            published_only: false,
+        })
+        .await
+    }
+
+    pub async fn list_visual_novel_gallery(
+        &self,
+    ) -> Result<Vec<VisualNovelWorkProfileRecord>, SpacetimeClientError> {
+        self.list_visual_novel_works_with_input(VisualNovelWorksListInput {
+            // 中文注释：公开列表只依赖 published_only，owner_user_id 用固定值满足 procedure 输入契约。
+            owner_user_id: "visual-novel-public-gallery".to_string(),
+            published_only: true,
+        })
+        .await
+    }
+
+    async fn list_visual_novel_works_with_input(
+        &self,
+        procedure_input: VisualNovelWorksListInput,
+    ) -> Result<Vec<VisualNovelWorkProfileRecord>, SpacetimeClientError> {
+        self.call_after_connect(move |connection, sender| {
+            connection.procedures().list_visual_novel_works_then(
+                procedure_input,
+                move |_, result| {
+                    let mapped = result
+                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
+                        .and_then(map_visual_novel_works_procedure_result);
+                    send_once(&sender, mapped);
+                },
+            );
+        })
+        .await
+    }
+
+    pub async fn get_visual_novel_work_detail(
+        &self,
+        profile_id: String,
+        owner_user_id: String,
+    ) -> Result<VisualNovelWorkProfileRecord, SpacetimeClientError> {
+        let procedure_input = VisualNovelWorkGetInput {
+            profile_id,
+            owner_user_id,
+        };
+
+        self.call_after_connect(move |connection, sender| {
+            connection.procedures().get_visual_novel_work_detail_then(
+                procedure_input,
+                move |_, result| {
+                    let mapped = result
+                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
+                        .and_then(map_visual_novel_work_procedure_result);
+                    send_once(&sender, mapped);
+                },
+            );
+        })
+        .await
+    }
+
+    pub async fn delete_visual_novel_work(
+        &self,
+        profile_id: String,
+        owner_user_id: String,
+    ) -> Result<Vec<VisualNovelWorkProfileRecord>, SpacetimeClientError> {
+        let procedure_input = VisualNovelWorkDeleteInput {
+            profile_id,
+            owner_user_id,
+        };
+
+        self.call_after_connect(move |connection, sender| {
+            connection.procedures().delete_visual_novel_work_then(
+                procedure_input,
+                move |_, result| {
+                    let mapped = result
+                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
+                        .and_then(map_visual_novel_works_procedure_result);
+                    send_once(&sender, mapped);
+                },
+            );
+        })
+        .await
+    }
+
+    pub async fn start_visual_novel_run(
+        &self,
+        input: VisualNovelRunStartRecordInput,
+    ) -> Result<VisualNovelRunRecord, SpacetimeClientError> {
+        let procedure_input = VisualNovelRunStartInput {
+            run_id: input.run_id,
+            owner_user_id: input.owner_user_id,
+            profile_id: input.profile_id,
+            mode: input.mode,
+            snapshot_json: input.snapshot_json,
+            started_at_micros: input.started_at_micros,
+        };
+
+        self.call_after_connect(move |connection, sender| {
+            connection
+                .procedures()
+                .start_visual_novel_run_then(procedure_input, move |_, result| {
+                    let mapped = result
+                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
+                        .and_then(map_visual_novel_run_procedure_result);
+                    send_once(&sender, mapped);
+                });
+        })
+        .await
+    }
+
+    pub async fn get_visual_novel_run(
+        &self,
+        run_id: String,
+        owner_user_id: String,
+    ) -> Result<VisualNovelRunRecord, SpacetimeClientError> {
+        let procedure_input = VisualNovelRunGetInput {
+            run_id,
+            owner_user_id,
+        };
+
+        self.call_after_connect(move |connection, sender| {
+            connection
+                .procedures()
+                .get_visual_novel_run_then(procedure_input, move |_, result| {
+                    let mapped = result
+                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
+                        .and_then(map_visual_novel_run_procedure_result);
+                    send_once(&sender, mapped);
+                });
+        })
+        .await
+    }
+
+    pub async fn upsert_visual_novel_run_snapshot(
+        &self,
+        input: VisualNovelRunSnapshotRecordInput,
+    ) -> Result<VisualNovelRunRecord, SpacetimeClientError> {
+        let procedure_input = VisualNovelRunSnapshotUpsertInput {
+            run_id: input.run_id,
+            owner_user_id: input.owner_user_id,
+            status: input.status,
+            current_scene_id: input.current_scene_id,
+            current_phase_id: input.current_phase_id,
+            visible_character_ids_json: input.visible_character_ids_json,
+            flags_json: input.flags_json,
+            metrics_json: input.metrics_json,
+            available_choices_json: input.available_choices_json,
+            text_mode_enabled: input.text_mode_enabled,
+            snapshot_json: input.snapshot_json,
+            updated_at_micros: input.updated_at_micros,
+        };
+
+        self.call_after_connect(move |connection, sender| {
+            connection.procedures().upsert_visual_novel_run_snapshot_then(
+                procedure_input,
+                move |_, result| {
+                    let mapped = result
+                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
+                        .and_then(map_visual_novel_run_procedure_result);
+                    send_once(&sender, mapped);
+                },
+            );
+        })
+        .await
+    }
+
+    pub async fn append_visual_novel_runtime_history_entry(
+        &self,
+        input: VisualNovelHistoryEntryRecordInput,
+    ) -> Result<Vec<VisualNovelHistoryEntryRecord>, SpacetimeClientError> {
+        let procedure_input = VisualNovelRuntimeHistoryAppendInput {
+            entry_id: input.entry_id,
+            run_id: input.run_id,
+            owner_user_id: input.owner_user_id,
+            turn_index: input.turn_index,
+            source: input.source,
+            action_text: input.action_text,
+            steps_json: input.steps_json,
+            snapshot_before_hash: input.snapshot_before_hash,
+            snapshot_after_hash: input.snapshot_after_hash,
+            created_at_micros: input.created_at_micros,
+        };
+
+        self.call_after_connect(move |connection, sender| {
+            connection
+                .procedures()
+                .append_visual_novel_runtime_history_entry_then(procedure_input, move |_, result| {
+                    let mapped = result
+                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
+                        .and_then(map_visual_novel_history_procedure_result);
+                    send_once(&sender, mapped);
+                });
+        })
+        .await
+    }
+
+    pub async fn list_visual_novel_runtime_history(
+        &self,
+        run_id: String,
+        owner_user_id: String,
+    ) -> Result<Vec<VisualNovelHistoryEntryRecord>, SpacetimeClientError> {
+        let procedure_input = VisualNovelRuntimeHistoryListInput {
+            run_id,
+            owner_user_id,
+        };
+
+        self.call_after_connect(move |connection, sender| {
+            connection.procedures().list_visual_novel_runtime_history_then(
+                procedure_input,
+                move |_, result| {
+                    let mapped = result
+                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
+                        .and_then(map_visual_novel_history_procedure_result);
+                    send_once(&sender, mapped);
+                },
+            );
+        })
+        .await
+    }
+
+    pub async fn record_visual_novel_runtime_event(
+        &self,
+        input: crate::mapper::VisualNovelRuntimeEventRecordInput,
+    ) -> Result<VisualNovelRuntimeEventRecord, SpacetimeClientError> {
+        let procedure_input = crate::module_bindings::VisualNovelRuntimeEventRecordInput {
+            event_id: input.event_id,
+            run_id: input.run_id,
+            owner_user_id: input.owner_user_id,
+            profile_id: input.profile_id,
+            event_kind: input.event_kind,
+            client_event_id: input.client_event_id,
+            history_entry_id: input.history_entry_id,
+            payload_json: input.payload_json,
+            occurred_at_micros: input.occurred_at_micros,
+        };
+
+        self.call_after_connect(move |connection, sender| {
+            connection.procedures().record_visual_novel_runtime_event_then(
+                procedure_input,
+                move |_, result| {
+                    let mapped = result
+                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
+                        .and_then(map_visual_novel_runtime_event_procedure_result);
+                    send_once(&sender, mapped);
+                },
+            );
+        })
+        .await
+    }
+}